@k8slens/extensions 5.3.1-git.e5c1eba9cb.0 → 5.3.1-git.eb93a2eee7.0

package/dist/src/main/{kube-auth-proxy.d.ts → kube-auth-proxy/kube-auth-proxy.d.ts}

@@ -20,22 +20,25 @@
  */
 /// <reference types="node" />
 import { ChildProcess } from "child_process";
-import type { Cluster } from "./cluster";
-import { Kubectl } from "./kubectl";
+import type { Cluster } from "../../common/cluster/cluster";
+interface Dependencies {
+    getProxyBinPath: () => Promise<string>;
+}
 export declare class KubeAuthProxy {
+    private dependencies;
+    protected readonly cluster: Cluster;
+    protected readonly env: NodeJS.ProcessEnv;
     readonly apiPrefix: string;
     get port(): number;
-    protected _port?: number;
-    protected cluster: Cluster;
-    protected env: NodeJS.ProcessEnv;
-    protected proxyProcess: ChildProcess;
-    protected kubectl: Kubectl;
+    protected _port: number;
+    protected proxyProcess?: ChildProcess;
+    protected readonly acceptHosts: string;
     protected ready: boolean;
-    constructor(cluster: Cluster, env: NodeJS.ProcessEnv);
-    get acceptHosts(): string;
+    constructor(dependencies: Dependencies, cluster: Cluster, env: NodeJS.ProcessEnv);
     get whenReady(): Promise<void> & {
         cancel(): void;
     };
     run(): Promise<void>;
     exit(): void;
 }
+export {};

package/dist/src/main/kubeconfig-manager/create-kubeconfig-manager.injectable.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="@ogre-tools/injectable" />
+import type { Cluster } from "../../common/cluster/cluster";
+import { KubeconfigManager } from "./kubeconfig-manager";
+export interface KubeConfigManagerInstantiationParameter {
+    cluster: Cluster;
+}
+declare const createKubeconfigManagerInjectable: import("@ogre-tools/injectable").Injectable<import("@ogre-tools/injectable").InjectionToken<(cluster: Cluster) => KubeconfigManager, unknown>, (cluster: Cluster) => KubeconfigManager, unknown>;
+export default createKubeconfigManagerInjectable;

package/dist/src/main/{kubeconfig-manager.d.ts → kubeconfig-manager/kubeconfig-manager.d.ts}

@@ -18,18 +18,34 @@
  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-import type { Cluster } from "./cluster";
-import type { ContextHandler } from "./context-handler";
+import type { Cluster } from "../../common/cluster/cluster";
+import type { ContextHandler } from "../context-handler/context-handler";
+interface Dependencies {
+    directoryForTemp: string;
+}
 export declare class KubeconfigManager {
+    private dependencies;
     protected cluster: Cluster;
+    /**
+     * The path to the temp config file
+     *
+     * - if `string` then path
+     * - if `null` then not yet created
+     * - if `undefined` then unlinked by calling `clear()`
+     */
+    protected tempFilePath: string | null | undefined;
     protected contextHandler: ContextHandler;
-    protected configDir: string;
-    protected tempFile: string;
-    constructor(cluster: Cluster, contextHandler: ContextHandler);
+    constructor(dependencies: Dependencies, cluster: Cluster);
+    /**
+     *
+     * @returns The path to the temporary kubeconfig
+     */
     getPath(): Promise<string>;
+    /**
+     * Deletes the temporary kubeconfig file
+     */
     clear(): Promise<void>;
-    unlink(): Promise<void>;
-    protected init(): Promise<void>;
+    protected ensureFile(): Promise<void>;
     get resolveProxyUrl(): string;
     /**
      * Creates new "temporary" kubeconfig that point to the kubectl-proxy.
@@ -37,3 +53,4 @@ export declare class KubeconfigManager {
      */
     protected createProxyKubeconfig(): Promise<string>;
 }
+export {};

package/dist/src/main/kubectl/bundled-kubectl.injectable.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="@ogre-tools/injectable" />
+declare const bundledKubectlInjectable: import("@ogre-tools/injectable").Injectable<import("@ogre-tools/injectable").InjectionToken<import("./kubectl").Kubectl, unknown>, import("./kubectl").Kubectl, unknown>;
+export default bundledKubectlInjectable;

package/dist/src/main/kubectl/create-kubectl.injectable.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="@ogre-tools/injectable" />
+import { Kubectl } from "./kubectl";
+declare const createKubectlInjectable: import("@ogre-tools/injectable").Injectable<import("@ogre-tools/injectable").InjectionToken<(clusterVersion: string) => Kubectl, unknown>, (clusterVersion: string) => Kubectl, unknown>;
+export default createKubectlInjectable;

package/dist/src/main/kubectl/directory-for-kubectl-binaries/directory-for-kubectl-binaries.injectable.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="@ogre-tools/injectable" />
+declare const directoryForKubectlBinariesInjectable: import("@ogre-tools/injectable").Injectable<import("@ogre-tools/injectable").InjectionToken<string, unknown>, string, unknown>;
+export default directoryForKubectlBinariesInjectable;

package/dist/src/main/{kubectl.d.ts → kubectl/kubectl.d.ts}

@@ -19,22 +19,29 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 export declare function bundledKubectlPath(): string;
+interface Dependencies {
+    directoryForKubectlBinaries: string;
+    userStore: {
+        kubectlBinariesPath?: string;
+        downloadBinariesPath?: string;
+        downloadKubectlBinaries: boolean;
+        downloadMirror: string;
+    };
+}
 export declare class Kubectl {
+    private dependencies;
     kubectlVersion: string;
     protected directory: string;
     protected url: string;
     protected path: string;
     protected dirname: string;
-    static get kubectlDir(): string;
     static readonly bundledKubectlVersion: string;
     static invalidBundle: boolean;
-    private static bundledInstance;
-    static bundled(): Kubectl;
-    constructor(clusterVersion: string);
+    constructor(dependencies: Dependencies, clusterVersion: string);
     getBundledPath(): string;
     getPathFromPreferences(): string;
     protected getDownloadDir(): string;
-    getPath(bundled?: boolean): Promise<string>;
+    getPath: (bundled?: boolean) => Promise<string>;
     binDir(): Promise<string>;
     checkBinary(path: string, checkVersion?: boolean): Promise<boolean>;
     protected checkBundled(): Promise<boolean>;
@@ -43,3 +50,4 @@ export declare class Kubectl {
     protected writeInitScripts(): Promise<void>;
     protected getDownloadMirror(): string;
 }
+export {};

package/dist/src/main/lens-proxy.d.ts

@@ -22,9 +22,9 @@
 import type http from "http";
 import httpProxy from "http-proxy";
 import type { Router } from "./router";
-import type { ContextHandler } from "./context-handler";
+import type { ContextHandler } from "./context-handler/context-handler";
 import { Singleton } from "../common/utils";
-import type { Cluster } from "./cluster";
+import type { Cluster } from "../common/cluster/cluster";
 import type { ProxyApiRequestArgs } from "./proxy-functions";
 declare type GetClusterForRequest = (req: http.IncomingMessage) => Cluster | null;
 export interface LensProxyFunctions {
@@ -43,9 +43,16 @@ export declare class LensProxy extends Singleton {
     protected getClusterForRequest: GetClusterForRequest;
     port: number;
     constructor(router: Router, { shellApiRequest, kubeApiRequest, getClusterForRequest }: LensProxyFunctions);
+    /**
+     * Starts to listen on an OS provided port. Will reject if the server throws
+     * an error.
+     *
+     * Resolves with the port number that was picked
+     */
+    private attemptToListen;
     /**
      * Starts the lens proxy.
-     * @resolves After the server is listening
+     * @resolves After the server is listening on a good port
      * @rejects if there is an error before that happens
      */
     listen(): Promise<void>;

package/dist/src/main/menu/electron-menu-items.injectable.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="@ogre-tools/injectable" />
+declare const electronMenuItemsInjectable: import("@ogre-tools/injectable").Injectable<import("@ogre-tools/injectable").InjectionToken<import("mobx").IComputedValue<import("./menu-registration").MenuRegistration[]>, unknown>, import("mobx").IComputedValue<import("./menu-registration").MenuRegistration[]>, unknown>;
+export default electronMenuItemsInjectable;

package/dist/src/main/menu/electron-menu-items.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/main/{menu.d.ts → menu/menu.d.ts}

@@ -18,9 +18,16 @@
  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-import { BrowserWindow } from "electron";
-import type { WindowManager } from "./window-manager";
+import { BrowserWindow, MenuItemConstructorOptions } from "electron";
+import { IComputedValue } from "mobx";
+import type { WindowManager } from "../window-manager";
+import type { MenuRegistration } from "./menu-registration";
 export declare type MenuTopId = "mac" | "file" | "edit" | "view" | "help";
-export declare function initMenu(windowManager: WindowManager): import("mobx").IReactionDisposer;
+interface MenuItemsOpts extends MenuItemConstructorOptions {
+    submenu?: MenuItemConstructorOptions[];
+}
+export declare function initMenu(windowManager: WindowManager, electronMenuItems: IComputedValue<MenuRegistration[]>): import("mobx").IReactionDisposer;
 export declare function showAbout(browserWindow: BrowserWindow): void;
-export declare function buildMenu(windowManager: WindowManager): void;
+export declare function getAppMenu(windowManager: WindowManager, electronMenuItems: MenuRegistration[]): MenuItemsOpts[];
+export declare function buildMenu(windowManager: WindowManager, electronMenuItems: MenuRegistration[]): void;
+export {};

package/dist/src/main/protocol-handler/index.d.ts

@@ -18,4 +18,4 @@
  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-export * from "./router";
+export * from "./lens-protocol-router-main/lens-protocol-router-main";

package/dist/src/main/protocol-handler/{router.d.ts → lens-protocol-router-main/lens-protocol-router-main.d.ts}

@@ -18,18 +18,25 @@
  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-import * as proto from "../../common/protocol-handler";
+import * as proto from "../../../common/protocol-handler";
 import URLParse from "url-parse";
-import type { LensExtension } from "../../extensions/lens-extension";
-import { RouteAttempt } from "../../common/protocol-handler";
+import type { LensExtension } from "../../../extensions/lens-extension";
+import { RouteAttempt } from "../../../common/protocol-handler";
+import type { ExtensionLoader } from "../../../extensions/extension-loader";
+import type { ExtensionsStore } from "../../../extensions/extensions-store/extensions-store";
 export interface FallbackHandler {
     (name: string): Promise<boolean>;
 }
+interface Dependencies {
+    extensionLoader: ExtensionLoader;
+    extensionsStore: ExtensionsStore;
+}
 export declare class LensProtocolRouterMain extends proto.LensProtocolRouter {
+    protected dependencies: Dependencies;
     private missingExtensionHandlers;
     rendererLoaded: boolean;
-    protected disposers: import("../../common/utils").ExtendableDisposer;
-    constructor();
+    protected disposers: import("../../../common/utils").ExtendableDisposer;
+    constructor(dependencies: Dependencies);
     cleanup(): void;
     /**
      * Find the most specific registered handler, if it exists, and invoke it.
@@ -39,9 +46,9 @@ export declare class LensProtocolRouterMain extends proto.LensProtocolRouter {
      */
     route(rawUrl: string): Promise<void>;
     protected _executeMissingExtensionHandlers(extensionName: string): Promise<boolean>;
-    protected _findMatchingExtensionByName(url: URLParse): Promise<LensExtension | string>;
-    protected _routeToInternal(url: URLParse): RouteAttempt;
-    protected _routeToExtension(url: URLParse): Promise<RouteAttempt>;
+    protected _findMatchingExtensionByName(url: URLParse<Record<string, string>>): Promise<LensExtension | string>;
+    protected _routeToInternal(url: URLParse<Record<string, string>>): RouteAttempt;
+    protected _routeToExtension(url: URLParse<Record<string, string>>): Promise<RouteAttempt>;
     /**
      * Add a function to the list which will be sequentially called if an extension
      * is not found while routing to the extensions
@@ -49,3 +56,4 @@ export declare class LensProtocolRouterMain extends proto.LensProtocolRouter {
      */
     addMissingExtensionHandler(handler: FallbackHandler): void;
 }
+export {};

package/dist/src/main/protocol-handler/lens-protocol-router-main/lens-protocol-router-main.injectable.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="@ogre-tools/injectable" />
+import { LensProtocolRouterMain } from "./lens-protocol-router-main";
+declare const lensProtocolRouterMainInjectable: import("@ogre-tools/injectable").Injectable<import("@ogre-tools/injectable").InjectionToken<LensProtocolRouterMain, unknown>, LensProtocolRouterMain, unknown>;
+export default lensProtocolRouterMainInjectable;

package/dist/src/main/proxy-functions/index.d.ts

@@ -18,6 +18,5 @@
  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-export * from "./shell-api-request";
 export * from "./kube-api-request";
 export * from "./types";

package/dist/src/main/proxy-functions/shell-api-request/shell-api-request.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Copyright (c) 2021 OpenLens Authors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+import WebSocket from "ws";
+import type { ProxyApiRequestArgs } from "../types";
+import type { Cluster } from "../../../common/cluster/cluster";
+import type { ClusterId } from "../../../common/cluster-types";
+interface Dependencies {
+    authenticateRequest: (clusterId: ClusterId, tabId: string, shellToken: string) => boolean;
+    createShellSession: (args: {
+        webSocket: WebSocket;
+        cluster: Cluster;
+        tabId: string;
+        nodeName?: string;
+    }) => {
+        open: () => Promise<void>;
+    };
+}
+export declare const shellApiRequest: ({ createShellSession, authenticateRequest }: Dependencies) => ({ req, socket, head }: ProxyApiRequestArgs) => void;
+export {};

package/dist/src/main/proxy-functions/shell-api-request/shell-api-request.injectable.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="@ogre-tools/injectable" />
+declare const shellApiRequestInjectable: import("@ogre-tools/injectable").Injectable<import("@ogre-tools/injectable").InjectionToken<({ req, socket, head }: import("..").ProxyApiRequestArgs) => void, unknown>, ({ req, socket, head }: import("..").ProxyApiRequestArgs) => void, unknown>;
+export default shellApiRequestInjectable;

package/dist/src/main/proxy-functions/shell-api-request/shell-request-authenticator/shell-request-authenticator.d.ts

@@ -0,0 +1,13 @@
+import type { ClusterId } from "../../../../common/cluster-types";
+export declare class ShellRequestAuthenticator {
+    private tokens;
+    init(): void;
+    /**
+     * Authenticates a single use token for creating a new shell
+     * @param clusterId The `ClusterId` for the shell
+     * @param tabId The ID for the shell
+     * @param token The value that is being presented as a one time authentication token
+     * @returns `true` if `token` was valid, false otherwise
+     */
+    authenticate: (clusterId: ClusterId, tabId: string, token: string) => boolean;
+}

package/dist/src/main/proxy-functions/shell-api-request/shell-request-authenticator/shell-request-authenticator.injectable.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="@ogre-tools/injectable" />
+import { ShellRequestAuthenticator } from "./shell-request-authenticator";
+declare const shellRequestAuthenticatorInjectable: import("@ogre-tools/injectable").Injectable<import("@ogre-tools/injectable").InjectionToken<ShellRequestAuthenticator, unknown>, ShellRequestAuthenticator, unknown>;
+export default shellRequestAuthenticatorInjectable;

package/dist/src/main/proxy-functions/types.d.ts

@@ -21,7 +21,7 @@
 /// <reference types="node" />
 import type http from "http";
 import type net from "net";
-import type { Cluster } from "../cluster";
+import type { Cluster } from "../../common/cluster/cluster";
 export interface ProxyApiRequestArgs {
     req: http.IncomingMessage;
     socket: net.Socket;

package/dist/src/main/resource-applier.d.ts

@@ -18,7 +18,7 @@
  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-import type { Cluster } from "./cluster";
+import type { Cluster } from "../common/cluster/cluster";
 import type { KubernetesObject } from "@kubernetes/client-node";
 import type { Patch } from "rfc6902";
 export declare class ResourceApplier {

package/dist/src/main/router/router.injectable.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="@ogre-tools/injectable" />
+import { Router } from "../router";
+declare const routerInjectable: import("@ogre-tools/injectable").Injectable<import("@ogre-tools/injectable").InjectionToken<Router, unknown>, Router, unknown>;
+export default routerInjectable;

package/dist/src/main/router.d.ts

@@ -20,7 +20,7 @@
  */
 /// <reference types="node" />
 import type http from "http";
-import type { Cluster } from "./cluster";
+import type { Cluster } from "../common/cluster/cluster";
 export interface RouterRequestOpts {
     req: http.IncomingMessage;
     res: http.ServerResponse;
@@ -48,12 +48,17 @@ export interface LensApiRequest<P = any> {
         req: http.IncomingMessage;
     };
 }
+interface Dependencies {
+    routePortForward: (request: LensApiRequest) => Promise<void>;
+}
 export declare class Router {
+    private dependencies;
     protected router: any;
     protected static rootPath: string;
-    constructor();
+    constructor(dependencies: Dependencies);
     route(cluster: Cluster, req: http.IncomingMessage, res: http.ServerResponse): Promise<boolean>;
     protected getRequest(opts: RouterRequestOpts): Promise<LensApiRequest>;
     protected static handleStaticFile({ params, response, raw: { req } }: LensApiRequest): Promise<void>;
     protected addRoutes(): void;
 }
+export {};

package/dist/src/main/routes/port-forward/create-port-forward.injectable.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="@ogre-tools/injectable" />
+import { PortForward, PortForwardArgs } from "./port-forward";
+declare const createPortForwardInjectable: import("@ogre-tools/injectable").Injectable<import("@ogre-tools/injectable").InjectionToken<(pathToKubeConfig: string, args: PortForwardArgs) => PortForward, unknown>, (pathToKubeConfig: string, args: PortForwardArgs) => PortForward, unknown>;
+export default createPortForwardInjectable;

package/dist/src/main/routes/port-forward/port-forward.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="node" />
+import { ChildProcessWithoutNullStreams } from "child_process";
+export interface PortForwardArgs {
+    clusterId: string;
+    kind: string;
+    namespace: string;
+    name: string;
+    port: number;
+    forwardPort: number;
+    protocol?: string;
+}
+interface Dependencies {
+    getKubectlBinPath: (bundled: boolean) => Promise<string>;
+}
+export declare class PortForward {
+    private dependencies;
+    pathToKubeConfig: string;
+    static portForwards: PortForward[];
+    static getPortforward(forward: PortForwardArgs): PortForward;
+    process: ChildProcessWithoutNullStreams;
+    clusterId: string;
+    kind: string;
+    namespace: string;
+    name: string;
+    port: number;
+    forwardPort: number;
+    protocol: string;
+    constructor(dependencies: Dependencies, pathToKubeConfig: string, args: PortForwardArgs);
+    start(): Promise<boolean>;
+    stop(): Promise<void>;
+}
+export {};

package/dist/src/main/routes/port-forward/route-port-forward/route-port-forward.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) 2021 OpenLens Authors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+import type { LensApiRequest } from "../../../router";
+import { PortForward, PortForwardArgs } from "../port-forward";
+interface Dependencies {
+    createPortForward: (pathToKubeConfig: string, args: PortForwardArgs) => PortForward;
+}
+export declare const routePortForward: ({ createPortForward }: Dependencies) => (request: LensApiRequest) => Promise<void>;
+export {};

package/dist/src/main/routes/port-forward/route-port-forward/route-port-forward.injectable.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="@ogre-tools/injectable" />
+declare const routePortForwardInjectable: import("@ogre-tools/injectable").Injectable<import("@ogre-tools/injectable").InjectionToken<(request: import("../../../router").LensApiRequest<any>) => Promise<void>, unknown>, (request: import("../../../router").LensApiRequest<any>) => Promise<void>, unknown>;
+export default routePortForwardInjectable;

package/dist/src/main/routes/port-forward-route.d.ts

@@ -20,8 +20,6 @@
  */
 import type { LensApiRequest } from "../router";
 export declare class PortForwardRoute {
-    static routePortForward(request: LensApiRequest): Promise<void>;
     static routeCurrentPortForward(request: LensApiRequest): Promise<void>;
-    static routeAllPortForwards(request: LensApiRequest): Promise<void>;
     static routeCurrentPortForwardStop(request: LensApiRequest): Promise<void>;
 }

package/dist/src/main/shell-session/create-shell-session.injectable.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="@ogre-tools/injectable" />
+import type { Cluster } from "../../common/cluster/cluster";
+import type WebSocket from "ws";
+interface Args {
+    webSocket: WebSocket;
+    cluster: Cluster;
+    tabId: string;
+    nodeName?: string;
+}
+declare const createShellSessionInjectable: import("@ogre-tools/injectable").Injectable<import("@ogre-tools/injectable").InjectionToken<({ nodeName, ...rest }: Args) => import(".").LocalShellSession | import(".").NodeShellSession, unknown>, ({ nodeName, ...rest }: Args) => import(".").LocalShellSession | import(".").NodeShellSession, unknown>;
+export default createShellSessionInjectable;

package/dist/src/main/shell-session/index.d.ts

@@ -18,5 +18,5 @@
  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-export * from "./node-shell-session";
-export * from "./local-shell-session";
+export * from "./node-shell-session/node-shell-session";
+export * from "./local-shell-session/local-shell-session";

package/dist/src/main/shell-session/{local-shell-session.d.ts → local-shell-session/local-shell-session.d.ts}

@@ -18,7 +18,7 @@
  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-import { ShellSession } from "./shell-session";
+import { ShellSession } from "../shell-session";
 export declare class LocalShellSession extends ShellSession {
     ShellType: string;
     protected getPathEntries(): string[];

package/dist/src/main/shell-session/local-shell-session/local-shell-session.injectable.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="@ogre-tools/injectable" />
+import { LocalShellSession } from "./local-shell-session";
+import type { Cluster } from "../../../common/cluster/cluster";
+import type WebSocket from "ws";
+interface InstantiationParameter {
+    webSocket: WebSocket;
+    cluster: Cluster;
+    tabId: string;
+}
+declare const localShellSessionInjectable: import("@ogre-tools/injectable").Injectable<import("@ogre-tools/injectable").InjectionToken<LocalShellSession, InstantiationParameter>, LocalShellSession, InstantiationParameter>;
+export default localShellSessionInjectable;

package/dist/src/main/shell-session/{node-shell-session.d.ts → node-shell-session/node-shell-session.d.ts}

@@ -24,15 +24,16 @@
 import type WebSocket from "ws";
 import * as k8s from "@kubernetes/client-node";
 import type { KubeConfig } from "@kubernetes/client-node";
-import type { Cluster } from "../cluster";
-import { ShellSession } from "./shell-session";
+import type { Cluster } from "../../../common/cluster/cluster";
+import { ShellSession } from "../shell-session";
+import type { Kubectl } from "../../kubectl/kubectl";
 export declare class NodeShellSession extends ShellSession {
     protected nodeName: string;
     ShellType: string;
     protected readonly podName: string;
     protected kc: KubeConfig;
     protected readonly cwd: string | undefined;
-    constructor(socket: WebSocket, cluster: Cluster, nodeName: string, terminalId: string);
+    constructor(nodeName: string, kubectl: Kubectl, socket: WebSocket, cluster: Cluster, terminalId: string);
     open(): Promise<void>;
     protected createNodeShellPod(): Promise<{
         response: import("http").IncomingMessage;

package/dist/src/main/shell-session/node-shell-session/node-shell-session.injectable.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="@ogre-tools/injectable" />
+import type { Cluster } from "../../../common/cluster/cluster";
+import type WebSocket from "ws";
+import { NodeShellSession } from "./node-shell-session";
+interface InstantiationParameter {
+    webSocket: WebSocket;
+    cluster: Cluster;
+    tabId: string;
+    nodeName: string;
+}
+declare const nodeShellSessionInjectable: import("@ogre-tools/injectable").Injectable<import("@ogre-tools/injectable").InjectionToken<NodeShellSession, InstantiationParameter>, NodeShellSession, InstantiationParameter>;
+export default nodeShellSessionInjectable;

package/dist/src/main/shell-session/shell-session.d.ts

@@ -18,8 +18,8 @@
  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-import type { Cluster } from "../cluster";
-import { Kubectl } from "../kubectl";
+import type { Cluster } from "../../common/cluster/cluster";
+import type { Kubectl } from "../kubectl/kubectl";
 import type WebSocket from "ws";
 import * as pty from "node-pty";
 import { TerminalMessage } from "../../renderer/api/terminal-api";
@@ -103,6 +103,7 @@ export declare enum WebSocketCloseEvent {
     TlsHandshake = 1015
 }
 export declare abstract class ShellSession {
+    protected kubectl: Kubectl;
     protected websocket: WebSocket;
     protected cluster: Cluster;
     abstract ShellType: string;
@@ -113,7 +114,6 @@ export declare abstract class ShellSession {
      * quit
      */
     static cleanup(): void;
-    protected kubectl: Kubectl;
     protected running: boolean;
     protected kubectlBinDirP: Promise<string>;
     protected kubeconfigPathP: Promise<string>;
@@ -123,7 +123,7 @@ export declare abstract class ShellSession {
         shellProcess: pty.IPty;
         resume: boolean;
     };
-    constructor(websocket: WebSocket, cluster: Cluster, terminalId: string);
+    constructor(kubectl: Kubectl, websocket: WebSocket, cluster: Cluster, terminalId: string);
     protected send(message: TerminalMessage): void;
     protected getCwd(env: Record<string, string>): Promise<string>;
     protected openShellProcess(shell: string, args: string[], env: Record<string, string>): Promise<void>;

package/dist/src/main/tray/tray-menu-items.injectable.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="@ogre-tools/injectable" />
+declare const trayItemsInjectable: import("@ogre-tools/injectable").Injectable<import("@ogre-tools/injectable").InjectionToken<import("mobx").IComputedValue<import("./tray-menu-registration").TrayMenuRegistration[]>, unknown>, import("mobx").IComputedValue<import("./tray-menu-registration").TrayMenuRegistration[]>, unknown>;
+export default trayItemsInjectable;

package/dist/src/main/tray/tray-menu-items.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/main/{tray.d.ts → tray/tray.d.ts}

@@ -19,7 +19,9 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 import { Tray } from "electron";
-import type { WindowManager } from "./window-manager";
+import { IComputedValue } from "mobx";
+import type { WindowManager } from "../window-manager";
+import type { TrayMenuRegistration } from "./tray-menu-registration";
 export declare let tray: Tray;
 export declare function getTrayIcon(): string;
-export declare function initTray(windowManager: WindowManager): () => void;
+export declare function initTray(windowManager: WindowManager, trayMenuItems: IComputedValue<TrayMenuRegistration[]>): () => void;