plugin-cluster-manager 1.0.12

package/dist/node_modules/@kubernetes/client-node/dist/util.d.ts

@@ -0,0 +1,31 @@
+import { CoreV1Api, V1Container, V1Pod } from './gen/api';
+export declare function podsForNode(api: CoreV1Api, nodeName: string): Promise<V1Pod[]>;
+export declare function findSuffix(quantity: string): string;
+export declare function quantityToScalar(quantity: string): number | bigint;
+export declare class ResourceStatus {
+    readonly request: bigint | number;
+    readonly limit: bigint | number;
+    readonly resourceType: string;
+    constructor(request: bigint | number, limit: bigint | number, resourceType: string);
+}
+export declare function totalCPUForContainer(container: V1Container): ResourceStatus;
+export declare function totalMemoryForContainer(container: V1Container): ResourceStatus;
+export declare function totalCPU(pod: V1Pod): ResourceStatus;
+export declare function totalMemory(pod: V1Pod): ResourceStatus;
+export declare function add(n1: number | bigint, n2: number | bigint): number | bigint;
+export declare function containerTotalForResource(container: V1Container, resource: string): ResourceStatus;
+export declare function totalForResource(pod: V1Pod, resource: string): ResourceStatus;
+export declare function generateTmpFileName(): Promise<string>;
+/**
+ * If you don't want to or can't await a promise right await and need to store
+ * it in a variable to await it later, wrap it with this function.
+ * Otherwise, if the promise rejects before you await it, it will cause an
+ * unhandled promise rejection which can cause process termination (in node).
+ */
+export declare const awaitLater: <T, P extends Promise<T>>(p: P) => P;
+export interface ResolvablePromise<T> extends Promise<T> {
+    resolve: (value: T) => void;
+    reject: (error: Error) => void;
+}
+export declare const resolvablePromise: <T>() => ResolvablePromise<T>;
+export declare const sleep: (ms: number) => Promise<void>;

package/dist/node_modules/@kubernetes/client-node/dist/util.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = exports.resolvablePromise = exports.awaitLater = exports.ResourceStatus = void 0;
+exports.podsForNode = podsForNode;
+exports.findSuffix = findSuffix;
+exports.quantityToScalar = quantityToScalar;
+exports.totalCPUForContainer = totalCPUForContainer;
+exports.totalMemoryForContainer = totalMemoryForContainer;
+exports.totalCPU = totalCPU;
+exports.totalMemory = totalMemory;
+exports.add = add;
+exports.containerTotalForResource = containerTotalForResource;
+exports.totalForResource = totalForResource;
+exports.generateTmpFileName = generateTmpFileName;
+const os_1 = require("os");
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+async function podsForNode(api, nodeName) {
+    const allPods = await api.listPodForAllNamespaces();
+    return allPods.body.items.filter((pod) => pod.spec.nodeName === nodeName);
+}
+function findSuffix(quantity) {
+    let ix = quantity.length - 1;
+    while (ix >= 0 && !/[\.0-9]/.test(quantity.charAt(ix))) {
+        ix--;
+    }
+    return ix === -1 ? '' : quantity.substring(ix + 1);
+}
+function quantityToScalar(quantity) {
+    if (!quantity) {
+        return 0;
+    }
+    const suffix = findSuffix(quantity);
+    if (suffix === '') {
+        const num = Number(quantity).valueOf();
+        if (isNaN(num)) {
+            throw new Error('Unknown quantity ' + quantity);
+        }
+        return num;
+    }
+    switch (suffix) {
+        case 'n':
+            return Number(quantity.slice(0, quantity.length - 1)).valueOf() / 1000000000;
+        case 'u':
+            return Number(quantity.slice(0, quantity.length - 1)).valueOf() / 1000000;
+        case 'm':
+            return Number(quantity.slice(0, quantity.length - 1)).valueOf() / 1000.0;
+        case 'k':
+            return BigInt(quantity.slice(0, quantity.length - 1)) * BigInt(1000);
+        case 'M':
+            return BigInt(quantity.slice(0, quantity.length - 1)) * BigInt(1000 * 1000);
+        case 'G':
+            return BigInt(quantity.slice(0, quantity.length - 1)) * BigInt(1000 * 1000 * 1000);
+        case 'T':
+            return BigInt(quantity.slice(0, quantity.length - 1)) * BigInt(1000 * 1000 * 1000) * BigInt(1000);
+        case 'P':
+            return (BigInt(quantity.slice(0, quantity.length - 1)) *
+                BigInt(1000 * 1000 * 1000) *
+                BigInt(1000 * 1000));
+        case 'E':
+            return (BigInt(quantity.slice(0, quantity.length - 1)) *
+                BigInt(1000 * 1000 * 1000) *
+                BigInt(1000 * 1000 * 1000));
+        case 'Ki':
+            return BigInt(quantity.slice(0, quantity.length - 2)) * BigInt(1024);
+        case 'Mi':
+            return BigInt(quantity.slice(0, quantity.length - 2)) * BigInt(1024 * 1024);
+        case 'Gi':
+            return BigInt(quantity.slice(0, quantity.length - 2)) * BigInt(1024 * 1024 * 1024);
+        case 'Ti':
+            return BigInt(quantity.slice(0, quantity.length - 2)) * BigInt(1024 * 1024 * 1024) * BigInt(1024);
+        case 'Pi':
+            return (BigInt(quantity.slice(0, quantity.length - 2)) *
+                BigInt(1024 * 1024 * 1024) *
+                BigInt(1024 * 1024));
+        case 'Ei':
+            return (BigInt(quantity.slice(0, quantity.length - 2)) *
+                BigInt(1024 * 1024 * 1024) *
+                BigInt(1024 * 1024 * 1024));
+        default:
+            throw new Error(`Unknown suffix: ${suffix}`);
+    }
+}
+class ResourceStatus {
+    constructor(request, limit, resourceType) {
+        this.request = request;
+        this.limit = limit;
+        this.resourceType = resourceType;
+    }
+}
+exports.ResourceStatus = ResourceStatus;
+function totalCPUForContainer(container) {
+    return containerTotalForResource(container, 'cpu');
+}
+function totalMemoryForContainer(container) {
+    return containerTotalForResource(container, 'memory');
+}
+function totalCPU(pod) {
+    return totalForResource(pod, 'cpu');
+}
+function totalMemory(pod) {
+    return totalForResource(pod, 'memory');
+}
+function add(n1, n2) {
+    if (typeof n1 === 'number' && typeof n2 === 'number') {
+        return n1 + n2;
+    }
+    if (typeof n1 === 'number') {
+        return BigInt(Math.round(n1)) + BigInt(n2);
+    }
+    else if (typeof n2 === 'number') {
+        return BigInt(n1) + BigInt(Math.round(n2));
+    }
+    return BigInt(n1) + BigInt(n2);
+}
+function containerTotalForResource(container, resource) {
+    let reqTotal = 0;
+    let limitTotal = 0;
+    if (container.resources) {
+        if (container.resources.requests) {
+            reqTotal = add(reqTotal, quantityToScalar(container.resources.requests[resource]));
+        }
+        if (container.resources.limits) {
+            limitTotal = add(limitTotal, quantityToScalar(container.resources.limits[resource]));
+        }
+    }
+    return new ResourceStatus(reqTotal, limitTotal, resource);
+}
+function totalForResource(pod, resource) {
+    let reqTotal = 0;
+    let limitTotal = 0;
+    pod.spec.containers.forEach((container) => {
+        const containerTotal = containerTotalForResource(container, resource);
+        reqTotal = add(reqTotal, containerTotal.request);
+        limitTotal = add(limitTotal, containerTotal.limit);
+    });
+    return new ResourceStatus(reqTotal, limitTotal, resource);
+}
+async function generateTmpFileName() {
+    let tmpFileName;
+    let i = 0;
+    do {
+        tmpFileName = `${(0, os_1.tmpdir)()}/${(0, crypto_1.randomUUID)()}`;
+        try {
+            await fs_1.promises.access(tmpFileName, fs_1.constants.W_OK);
+            console.warn('Tmp file already exists');
+        }
+        catch (err) {
+            return tmpFileName;
+        }
+        i++;
+    } while (i < 10);
+    throw new Error('Cannot generate tmp file name');
+}
+/**
+ * If you don't want to or can't await a promise right await and need to store
+ * it in a variable to await it later, wrap it with this function.
+ * Otherwise, if the promise rejects before you await it, it will cause an
+ * unhandled promise rejection which can cause process termination (in node).
+ */
+const awaitLater = (p) => {
+    p.catch(() => { }); // tslint:disable-line:no-empty
+    return p;
+};
+exports.awaitLater = awaitLater;
+const resolvablePromise = () => {
+    let resolve;
+    let reject;
+    const promise = (0, exports.awaitLater)(new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    }));
+    promise.resolve = resolve;
+    promise.reject = reject;
+    return promise;
+};
+exports.resolvablePromise = resolvablePromise;
+const sleep = (ms) => {
+    return new Promise((resolve) => setTimeout(resolve));
+};
+exports.sleep = sleep;
+//# sourceMappingURL=util.js.map

package/dist/node_modules/@kubernetes/client-node/dist/watch.d.ts

@@ -0,0 +1,32 @@
+import request = require('request');
+import { Duplex } from 'stream';
+import { KubeConfig } from './config';
+export interface WatchUpdate {
+    type: string;
+    object: object;
+}
+export interface RequestResult {
+    pipe(stream: Duplex): void;
+    on(ev: string, cb: (arg: any) => void): void;
+    removeAllListeners(ev: string): void;
+    abort(): void;
+}
+export interface Response {
+    statusCode: number;
+    statusMessage: string;
+}
+export interface RequestInterface {
+    webRequest(opts: request.OptionsWithUri): RequestResult;
+}
+export declare class DefaultRequest implements RequestInterface {
+    private requestImpl;
+    constructor(requestImpl?: (opts: request.OptionsWithUri) => request.Request);
+    webRequest(opts: request.OptionsWithUri): RequestResult;
+}
+export declare class Watch {
+    static SERVER_SIDE_CLOSE: object;
+    config: KubeConfig;
+    private readonly requestImpl;
+    constructor(config: KubeConfig, requestImpl?: RequestInterface);
+    watch(path: string, queryParams: any, callback: (phase: string, apiObj: any, watchObj?: any) => void, done: (err: any) => void): Promise<any>;
+}

package/dist/node_modules/@kubernetes/client-node/dist/watch.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Watch = exports.DefaultRequest = void 0;
+const byline = require("byline");
+const request = require("request");
+class DefaultRequest {
+    constructor(requestImpl) {
+        this.requestImpl = requestImpl ? requestImpl : request;
+    }
+    // Using request lib can be confusing when combining Stream- with Callback-
+    // style API. We avoid the callback and handle HTTP response errors, that
+    // would otherwise require a different error handling, in a transparent way
+    // to the user (see github issue request/request#647 for more info).
+    webRequest(opts) {
+        const req = this.requestImpl(opts);
+        // pause the stream until we get a response not to miss any bytes
+        req.pause();
+        req.on('response', (resp) => {
+            if (resp.statusCode === 200) {
+                req.resume();
+            }
+            else {
+                const error = new Error(resp.statusMessage);
+                error.statusCode = resp.statusCode;
+                req.emit('error', error);
+            }
+        });
+        return req;
+    }
+}
+exports.DefaultRequest = DefaultRequest;
+class Watch {
+    constructor(config, requestImpl) {
+        this.config = config;
+        if (requestImpl) {
+            this.requestImpl = requestImpl;
+        }
+        else {
+            this.requestImpl = new DefaultRequest();
+        }
+    }
+    // Watch the resource and call provided callback with parsed json object
+    // upon event received over the watcher connection.
+    //
+    // "done" callback is called either when connection is closed or when there
+    // is an error. In either case, watcher takes care of properly closing the
+    // underlaying connection so that it doesn't leak any resources.
+    async watch(path, queryParams, callback, done) {
+        const cluster = this.config.getCurrentCluster();
+        if (!cluster) {
+            throw new Error('No currently active cluster');
+        }
+        const url = cluster.server + path;
+        queryParams.watch = true;
+        const headerParams = {};
+        const requestOptions = {
+            method: 'GET',
+            qs: queryParams,
+            headers: headerParams,
+            uri: url,
+            useQuerystring: true,
+            json: true,
+            pool: false,
+        };
+        await this.config.applyToRequest(requestOptions);
+        let req;
+        let doneCalled = false;
+        const doneCallOnce = (err) => {
+            if (!doneCalled) {
+                req.abort();
+                doneCalled = true;
+                done(err);
+            }
+        };
+        req = this.requestImpl.webRequest(requestOptions);
+        const stream = byline.createStream();
+        req.on('error', doneCallOnce);
+        req.on('socket', (socket) => {
+            socket.setTimeout(30000);
+            socket.setKeepAlive(true, 30000);
+        });
+        stream.on('error', doneCallOnce);
+        stream.on('close', () => doneCallOnce(null));
+        stream.on('data', (line) => {
+            let data;
+            try {
+                data = JSON.parse(line);
+            }
+            catch (ignore) {
+                // ignore parse errors
+                return;
+            }
+            callback(data.type, data.object, data);
+        });
+        req.pipe(stream);
+        return req;
+    }
+}
+exports.Watch = Watch;
+Watch.SERVER_SIDE_CLOSE = { error: 'Connection closed on server' };
+//# sourceMappingURL=watch.js.map

package/dist/node_modules/@kubernetes/client-node/dist/web-socket-handler.d.ts

@@ -0,0 +1,41 @@
+import WebSocket = require('isomorphic-ws');
+import stream = require('stream');
+import { V1Status } from './api';
+import { KubeConfig } from './config';
+export type TextHandler = (text: string) => boolean;
+export type BinaryHandler = (stream: number, buff: Buffer) => boolean;
+export interface WebSocketInterface {
+    connect(path: string, textHandler: TextHandler | null, binaryHandler: BinaryHandler | null): Promise<WebSocket.WebSocket>;
+}
+export interface StreamInterface {
+    stdin: stream.Readable;
+    stdout: stream.Writable;
+    stderr: stream.Writable;
+}
+export declare class WebSocketHandler implements WebSocketInterface {
+    readonly config: KubeConfig;
+    readonly socketFactory?: ((uri: string, protocols: string[], opts: WebSocket.ClientOptions) => WebSocket.WebSocket) | undefined;
+    readonly streams: StreamInterface;
+    static readonly StdinStream: number;
+    static readonly StdoutStream: number;
+    static readonly StderrStream: number;
+    static readonly StatusStream: number;
+    static readonly ResizeStream: number;
+    static readonly CloseStream: number;
+    static supportsClose(protocol: string): boolean;
+    static closeStream(streamNum: number, streams: StreamInterface): void;
+    static handleStandardStreams(streamNum: number, buff: Buffer, stdout: stream.Writable | null, stderr: stream.Writable | null): V1Status | null;
+    static handleStandardInput(ws: WebSocket.WebSocket, stdin: stream.Readable | any, streamNum?: number): boolean;
+    static processData(data: string | Buffer, ws: WebSocket.WebSocket | null, createWS: () => Promise<WebSocket.WebSocket>, streamNum?: number, retryCount?: number): Promise<WebSocket.WebSocket | null>;
+    static restartableHandleStandardInput(createWS: () => Promise<WebSocket.WebSocket>, stdin: stream.Readable | any, streamNum?: number, retryCount?: number): () => WebSocket.WebSocket | null;
+    constructor(config: KubeConfig, socketFactory?: ((uri: string, protocols: string[], opts: WebSocket.ClientOptions) => WebSocket.WebSocket) | undefined, streams?: StreamInterface);
+    /**
+     * Connect to a web socket endpoint.
+     * @param path The HTTP Path to connect to on the server.
+     * @param textHandler Callback for text over the web socket.
+     *      Returns true if the connection should be kept alive, false to disconnect.
+     * @param binaryHandler Callback for binary data over the web socket.
+     *      Returns true if the connection should be kept alive, false to disconnect.
+     */
+    connect(path: string, textHandler: ((text: string) => boolean) | null, binaryHandler: ((stream: number, buff: Buffer) => boolean) | null): Promise<WebSocket.WebSocket>;
+}

package/dist/node_modules/@kubernetes/client-node/dist/web-socket-handler.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketHandler = void 0;
+const WebSocket = require("isomorphic-ws");
+const protocols = [
+    'v5.channel.k8s.io',
+    'v4.channel.k8s.io',
+    'v3.channel.k8s.io',
+    'v2.channel.k8s.io',
+    'channel.k8s.io',
+];
+class WebSocketHandler {
+    static supportsClose(protocol) {
+        return protocol === 'v5.channel.k8s.io';
+    }
+    static closeStream(streamNum, streams) {
+        switch (streamNum) {
+            case WebSocketHandler.StdinStream:
+                streams.stdin.pause();
+                break;
+            case WebSocketHandler.StdoutStream:
+                streams.stdout.end();
+                break;
+            case WebSocketHandler.StderrStream:
+                streams.stderr.end();
+                break;
+        }
+    }
+    static handleStandardStreams(streamNum, buff, stdout, stderr) {
+        if (buff.length < 1) {
+            return null;
+        }
+        if (stdout && streamNum === WebSocketHandler.StdoutStream) {
+            stdout.write(buff);
+        }
+        else if (stderr && streamNum === WebSocketHandler.StderrStream) {
+            stderr.write(buff);
+        }
+        else if (streamNum === WebSocketHandler.StatusStream) {
+            // stream closing.
+            // Hacky, change tests to use the stream interface
+            if (stdout && stdout !== process.stdout) {
+                stdout.end();
+            }
+            if (stderr && stderr !== process.stderr) {
+                stderr.end();
+            }
+            return JSON.parse(buff.toString('utf8'));
+        }
+        else {
+            throw new Error('Unknown stream: ' + streamNum);
+        }
+        return null;
+    }
+    static handleStandardInput(ws, stdin, streamNum = 0) {
+        stdin.on('data', (data) => {
+            const buff = Buffer.alloc(data.length + 1);
+            buff.writeInt8(streamNum, 0);
+            if (data instanceof Buffer) {
+                data.copy(buff, 1);
+            }
+            else {
+                buff.write(data, 1);
+            }
+            ws.send(buff);
+        });
+        stdin.on('end', () => {
+            if (WebSocketHandler.supportsClose(ws.protocol)) {
+                const buff = Buffer.alloc(2);
+                buff.writeUint8(this.CloseStream, 0);
+                buff.writeUint8(this.StdinStream, 1);
+                ws.send(buff);
+            }
+            ws.close();
+        });
+        // Keep the stream open
+        return true;
+    }
+    static async processData(data, ws, createWS, streamNum = 0, retryCount = 3) {
+        const buff = Buffer.alloc(data.length + 1);
+        buff.writeInt8(streamNum, 0);
+        if (data instanceof Buffer) {
+            data.copy(buff, 1);
+        }
+        else {
+            buff.write(data, 1);
+        }
+        let i = 0;
+        for (; i < retryCount; ++i) {
+            if (ws !== null && ws.readyState === WebSocket.OPEN) {
+                ws.send(buff);
+                break;
+            }
+            else {
+                ws = await createWS();
+            }
+        }
+        // This throw doesn't go anywhere.
+        // TODO: Figure out the right way to return an error.
+        if (i >= retryCount) {
+            throw new Error("can't send data to ws");
+        }
+        return ws;
+    }
+    static restartableHandleStandardInput(createWS, stdin, streamNum = 0, retryCount = 3) {
+        if (retryCount < 0) {
+            throw new Error("retryCount can't be lower than 0.");
+        }
+        let queue = Promise.resolve();
+        let ws = null;
+        stdin.on('data', (data) => {
+            queue = queue.then(async () => {
+                ws = await WebSocketHandler.processData(data, ws, createWS, streamNum, retryCount);
+            });
+        });
+        stdin.on('end', () => {
+            if (ws) {
+                ws.close();
+            }
+        });
+        return () => ws;
+    }
+    // factory is really just for test injection
+    constructor(config, socketFactory, streams = {
+        stdin: process.stdin,
+        stdout: process.stdout,
+        stderr: process.stderr,
+    }) {
+        this.config = config;
+        this.socketFactory = socketFactory;
+        this.streams = streams;
+    }
+    /**
+     * Connect to a web socket endpoint.
+     * @param path The HTTP Path to connect to on the server.
+     * @param textHandler Callback for text over the web socket.
+     *      Returns true if the connection should be kept alive, false to disconnect.
+     * @param binaryHandler Callback for binary data over the web socket.
+     *      Returns true if the connection should be kept alive, false to disconnect.
+     */
+    async connect(path, textHandler, binaryHandler) {
+        const cluster = this.config.getCurrentCluster();
+        if (!cluster) {
+            throw new Error('No cluster is defined.');
+        }
+        const server = cluster.server;
+        const ssl = server.startsWith('https://');
+        const target = ssl ? server.slice(8) : server.slice(7);
+        const proto = ssl ? 'wss' : 'ws';
+        const uri = `${proto}://${target}${path}`;
+        const opts = {};
+        await this.config.applyToHTTPSOptions(opts);
+        return await new Promise((resolve, reject) => {
+            const client = this.socketFactory
+                ? this.socketFactory(uri, protocols, opts)
+                : new WebSocket(uri, protocols, opts);
+            let resolved = false;
+            client.onopen = () => {
+                resolved = true;
+                resolve(client);
+            };
+            client.onerror = (err) => {
+                if (!resolved) {
+                    reject(err);
+                }
+            };
+            client.onmessage = ({ data }) => {
+                // TODO: support ArrayBuffer and Buffer[] data types?
+                if (typeof data === 'string') {
+                    if (data.charCodeAt(0) === WebSocketHandler.CloseStream) {
+                        WebSocketHandler.closeStream(data.charCodeAt(1), this.streams);
+                    }
+                    if (textHandler && !textHandler(data)) {
+                        client.close();
+                    }
+                }
+                else if (data instanceof Buffer) {
+                    const streamNum = data.readUint8(0);
+                    if (streamNum === WebSocketHandler.CloseStream) {
+                        WebSocketHandler.closeStream(data.readInt8(1), this.streams);
+                    }
+                    if (binaryHandler && !binaryHandler(streamNum, data.subarray(1))) {
+                        client.close();
+                    }
+                }
+            };
+        });
+    }
+}
+exports.WebSocketHandler = WebSocketHandler;
+WebSocketHandler.StdinStream = 0;
+WebSocketHandler.StdoutStream = 1;
+WebSocketHandler.StderrStream = 2;
+WebSocketHandler.StatusStream = 3;
+WebSocketHandler.ResizeStream = 4;
+WebSocketHandler.CloseStream = 255;
+//# sourceMappingURL=web-socket-handler.js.map

package/dist/node_modules/@kubernetes/client-node/dist/yaml.d.ts

@@ -0,0 +1,4 @@
+import * as yaml from 'js-yaml';
+export declare function loadYaml<T>(data: string, opts?: yaml.LoadOptions): T;
+export declare function loadAllYaml(data: string, opts?: yaml.LoadOptions): any[];
+export declare function dumpYaml(object: any, opts?: yaml.DumpOptions): string;

package/dist/node_modules/@kubernetes/client-node/dist/yaml.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadYaml = loadYaml;
+exports.loadAllYaml = loadAllYaml;
+exports.dumpYaml = dumpYaml;
+const tslib_1 = require("tslib");
+const yaml = tslib_1.__importStar(require("js-yaml"));
+function loadYaml(data, opts) {
+    return yaml.load(data, opts);
+}
+function loadAllYaml(data, opts) {
+    return yaml.loadAll(data, undefined, opts);
+}
+function dumpYaml(object, opts) {
+    return yaml.dump(object, opts);
+}
+//# sourceMappingURL=yaml.js.map

package/dist/node_modules/@kubernetes/client-node/node_modules/.bin/js-yaml

@@ -0,0 +1,15 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/../../../../js-yaml/bin/js-yaml.js" "$@"
+  ret=$?
+else 
+  node  "$basedir/../../../../js-yaml/bin/js-yaml.js" "$@"
+  ret=$?
+fi
+exit $ret

package/dist/node_modules/@kubernetes/client-node/node_modules/.bin/js-yaml.cmd

@@ -0,0 +1,7 @@
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\..\..\..\..\js-yaml\bin\js-yaml.js" %*
+) ELSE (
+  @SETLOCAL
+  @SET PATHEXT=%PATHEXT:;.JS;=;%
+  node  "%~dp0\..\..\..\..\js-yaml\bin\js-yaml.js" %*
+)

package/dist/node_modules/@kubernetes/client-node/node_modules/.bin/jsonpath

@@ -0,0 +1,15 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/../jsonpath-plus/bin/jsonpath-cli.js" "$@"
+  ret=$?
+else 
+  node  "$basedir/../jsonpath-plus/bin/jsonpath-cli.js" "$@"
+  ret=$?
+fi
+exit $ret

package/dist/node_modules/@kubernetes/client-node/node_modules/.bin/jsonpath-plus

@@ -0,0 +1,15 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/../jsonpath-plus/bin/jsonpath-cli.js" "$@"
+  ret=$?
+else 
+  node  "$basedir/../jsonpath-plus/bin/jsonpath-cli.js" "$@"
+  ret=$?
+fi
+exit $ret

package/dist/node_modules/@kubernetes/client-node/node_modules/.bin/jsonpath-plus.cmd

@@ -0,0 +1,7 @@
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\..\jsonpath-plus\bin\jsonpath-cli.js" %*
+) ELSE (
+  @SETLOCAL
+  @SET PATHEXT=%PATHEXT:;.JS;=;%
+  node  "%~dp0\..\jsonpath-plus\bin\jsonpath-cli.js" %*
+)