@kubernetesjs/cli 0.0.3 → 0.1.0

package/config.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Read and parse a YAML file
+ * @param filePath Path to the YAML file
+ * @returns Parsed YAML content
+ */
+export declare function readYamlFile(filePath: string): any;
+/**
+ * Infer the resource type from a Kubernetes YAML
+ * @param resource The parsed Kubernetes resource
+ * @returns The resource type (lowercase)
+ */
+export declare function inferResourceType(resource: any): string;
+/**
+ * Get the current namespace from the local kubeconfig
+ * @returns The current namespace
+ */
+export declare function getCurrentNamespace(): string;
+/**
+ * Set the current namespace in the local kubeconfig
+ * @param namespace The namespace to set
+ */
+export declare function setCurrentNamespace(namespace: string): void;

package/config.js

@@ -0,0 +1,113 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readYamlFile = readYamlFile;
+exports.inferResourceType = inferResourceType;
+exports.getCurrentNamespace = getCurrentNamespace;
+exports.setCurrentNamespace = setCurrentNamespace;
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const yaml = __importStar(require("js-yaml"));
+const KUBECONFIG_PATH = (0, path_1.join)((0, os_1.homedir)(), '.kubeconfig');
+const DEFAULT_NAMESPACE = 'default';
+/**
+ * Read and parse a YAML file
+ * @param filePath Path to the YAML file
+ * @returns Parsed YAML content
+ */
+function readYamlFile(filePath) {
+    try {
+        const fileContent = (0, fs_1.readFileSync)(filePath, 'utf8');
+        return yaml.load(fileContent);
+    }
+    catch (error) {
+        console.error(`Error reading YAML file: ${error}`);
+        throw error;
+    }
+}
+/**
+ * Infer the resource type from a Kubernetes YAML
+ * @param resource The parsed Kubernetes resource
+ * @returns The resource type (lowercase)
+ */
+function inferResourceType(resource) {
+    if (!resource || !resource.kind) {
+        throw new Error('Invalid Kubernetes resource: missing kind');
+    }
+    return resource.kind.toLowerCase();
+}
+/**
+ * Get the current namespace from the local kubeconfig
+ * @returns The current namespace
+ */
+function getCurrentNamespace() {
+    try {
+        if (!(0, fs_1.existsSync)(KUBECONFIG_PATH)) {
+            return DEFAULT_NAMESPACE;
+        }
+        const configContent = (0, fs_1.readFileSync)(KUBECONFIG_PATH, 'utf8');
+        const config = JSON.parse(configContent);
+        return config.currentNamespace || DEFAULT_NAMESPACE;
+    }
+    catch (error) {
+        console.error(`Error reading kubeconfig: ${error}`);
+        return DEFAULT_NAMESPACE;
+    }
+}
+/**
+ * Set the current namespace in the local kubeconfig
+ * @param namespace The namespace to set
+ */
+function setCurrentNamespace(namespace) {
+    try {
+        let config = { currentNamespace: namespace };
+        if ((0, fs_1.existsSync)(KUBECONFIG_PATH)) {
+            try {
+                const configContent = (0, fs_1.readFileSync)(KUBECONFIG_PATH, 'utf8');
+                config = { ...JSON.parse(configContent), currentNamespace: namespace };
+            }
+            catch (error) {
+                console.error(`Error parsing existing kubeconfig: ${error}`);
+            }
+        }
+        (0, fs_1.writeFileSync)(KUBECONFIG_PATH, JSON.stringify(config, null, 2), 'utf8');
+        console.log(`Namespace set to "${namespace}"`);
+    }
+    catch (error) {
+        console.error(`Error setting namespace: ${error}`);
+        throw error;
+    }
+}

package/esm/commands/apply.js

@@ -0,0 +1,133 @@
+import chalk from 'chalk';
+import { KubernetesClient } from 'kubernetesjs';
+import { readYamlFile } from '../config';
+import * as fs from 'fs';
+async function promptYamlFilePath(prompter, argv) {
+    const question = {
+        type: 'text',
+        name: 'filePath',
+        message: 'Enter path to YAML file',
+        required: true
+    };
+    const { filePath } = await prompter.prompt(argv, [question]);
+    return filePath;
+}
+async function applyResource(client, resource, namespace) {
+    const kind = resource.kind.toLowerCase();
+    const name = resource.metadata?.name;
+    if (!name) {
+        throw new Error('Resource must have a name');
+    }
+    console.log(chalk.blue(`Applying ${kind} "${name}" in namespace ${namespace}...`));
+    try {
+        switch (kind) {
+            case 'deployment':
+                await client.createAppsV1NamespacedDeployment({
+                    path: { namespace },
+                    query: {
+                        pretty: 'true',
+                        fieldManager: 'kubernetesjs-cli'
+                    },
+                    body: resource
+                });
+                console.log(chalk.green(`Deployment "${name}" created/updated successfully`));
+                break;
+            case 'service':
+                await client.createCoreV1NamespacedService({
+                    path: { namespace },
+                    query: {
+                        pretty: 'true',
+                        fieldManager: 'kubernetesjs-cli'
+                    },
+                    body: resource
+                });
+                console.log(chalk.green(`Service "${name}" created/updated successfully`));
+                break;
+            case 'pod':
+                await client.createCoreV1NamespacedPod({
+                    path: { namespace },
+                    query: {
+                        pretty: 'true',
+                        fieldManager: 'kubernetesjs-cli'
+                    },
+                    body: resource
+                });
+                console.log(chalk.green(`Pod "${name}" created/updated successfully`));
+                break;
+            case 'configmap':
+                await client.createCoreV1NamespacedConfigMap({
+                    path: { namespace },
+                    query: {
+                        pretty: 'true',
+                        fieldManager: 'kubernetesjs-cli'
+                    },
+                    body: resource
+                });
+                console.log(chalk.green(`ConfigMap "${name}" created/updated successfully`));
+                break;
+            case 'secret':
+                await client.createCoreV1NamespacedSecret({
+                    path: { namespace },
+                    query: {
+                        pretty: 'true',
+                        fieldManager: 'kubernetesjs-cli'
+                    },
+                    body: resource
+                });
+                console.log(chalk.green(`Secret "${name}" created/updated successfully`));
+                break;
+            default:
+                console.log(chalk.yellow(`Resource kind "${kind}" not implemented yet`));
+        }
+    }
+    catch (error) {
+        console.error(chalk.red(`Error applying ${kind} "${name}": ${error}`));
+        throw error;
+    }
+}
+export default async (argv, prompter, _options) => {
+    try {
+        const client = new KubernetesClient({
+            restEndpoint: argv.clientUrl
+        });
+        const filePath = argv.f || argv._?.[0] || await promptYamlFilePath(prompter, argv);
+        if (!filePath) {
+            console.error(chalk.red('No file path provided'));
+            return;
+        }
+        if (!fs.existsSync(filePath)) {
+            console.error(chalk.red(`File not found: ${filePath}`));
+            return;
+        }
+        let resources;
+        try {
+            const content = readYamlFile(filePath);
+            if (Array.isArray(content)) {
+                resources = content;
+            }
+            else if (content.kind === 'List' && Array.isArray(content.items)) {
+                resources = content.items;
+            }
+            else {
+                resources = [content];
+            }
+        }
+        catch (error) {
+            console.error(chalk.red(`Error parsing YAML file: ${error}`));
+            return;
+        }
+        for (const resource of resources) {
+            try {
+                const namespace = resource.metadata?.namespace || argv.n || argv.namespace || 'default';
+                await applyResource(client, resource, namespace);
+            }
+            catch (error) {
+                console.error(chalk.red(`Failed to apply resource: ${error}`));
+            }
+        }
+        console.log(chalk.green('Apply completed'));
+    }
+    catch (error) {
+        console.error(chalk.red(`Error: ${error}`));
+    }
+};

package/esm/commands/cluster-info.js

@@ -0,0 +1,21 @@
+import chalk from 'chalk';
+import { KubernetesClient } from 'kubernetesjs';
+export default async (_argv, _prompter, _options) => {
+    try {
+        const client = new KubernetesClient({
+            restEndpoint: _argv.clientUrl
+        });
+        console.log(chalk.blue('Kubernetes cluster info:'));
+        const apiVersions = await client.getAPIVersions({
+            params: {},
+            query: {}
+        });
+        console.log(chalk.bold('\nAPI Versions:'));
+        if (apiVersions.apiVersion) {
+            console.log(apiVersions.apiVersion);
+        }
+    }
+    catch (error) {
+        console.error(chalk.red(`Error: ${error}`));
+    }
+};

package/esm/commands/config-handler.js

@@ -0,0 +1,43 @@
+import chalk from 'chalk';
+import * as fs from 'fs';
+import { readYamlFile, inferResourceType } from '../config';
+/**
+ * Handle the --config flag by parsing the YAML file and executing the appropriate command
+ * @param argv Command line arguments
+ * @param prompter Inquirerer instance
+ * @param options CLI options
+ * @param commandMap Map of available commands
+ */
+export default async (argv, prompter, options, commandMap) => {
+    if (!argv.config) {
+        return false;
+    }
+    const configPath = argv.config;
+    if (!fs.existsSync(configPath)) {
+        console.error(chalk.red(`Config file not found: ${configPath}`));
+        return true;
+    }
+    try {
+        const resource = readYamlFile(configPath);
+        const resourceType = inferResourceType(resource);
+        console.log(chalk.blue(`Detected resource type: ${resourceType}`));
+        let command;
+        command = 'apply';
+        const newArgv = {
+            ...argv,
+            _: [configPath],
+            f: configPath
+        };
+        if (commandMap[command]) {
+            await commandMap[command](newArgv, prompter, options);
+        }
+        else {
+            console.error(chalk.red(`No command found for resource type: ${resourceType}`));
+        }
+        return true;
+    }
+    catch (error) {
+        console.error(chalk.red(`Error processing config file: ${error}`));
+        return true;
+    }
+};

package/esm/commands/config.js

@@ -0,0 +1,67 @@
+import chalk from 'chalk';
+import { KubernetesClient } from 'kubernetesjs';
+import { getCurrentNamespace, setCurrentNamespace } from '../config';
+async function promptNamespace(prompter, argv, client) {
+    try {
+        const namespaces = await client.listCoreV1Namespace({
+            query: {}
+        });
+        if (!namespaces.items || namespaces.items.length === 0) {
+            console.log(chalk.yellow('No namespaces found'));
+            return '';
+        }
+        const options = namespaces.items.map(ns => ({
+            name: ns.metadata.name,
+            value: ns.metadata.name
+        }));
+        const question = {
+            type: 'autocomplete',
+            name: 'namespace',
+            message: 'Select namespace',
+            options,
+            maxDisplayLines: 10,
+            required: true
+        };
+        const { namespace } = await prompter.prompt(argv, [question]);
+        return namespace;
+    }
+    catch (error) {
+        console.error(chalk.red(`Error getting namespaces: ${error}`));
+        return '';
+    }
+}
+export default async (argv, prompter, _options) => {
+    try {
+        const client = new KubernetesClient({
+            restEndpoint: argv.clientUrl
+        });
+        const subcommand = argv._?.[0];
+        if (subcommand === 'get-context') {
+            const namespace = getCurrentNamespace();
+            console.log(chalk.green(`Current namespace: ${namespace}`));
+            return;
+        }
+        if (subcommand === 'set-context') {
+            if (argv.current !== true) {
+                console.error(chalk.red('Missing --current flag'));
+                return;
+            }
+            let namespace = argv.namespace;
+            if (!namespace) {
+                namespace = await promptNamespace(prompter, argv, client);
+                if (!namespace) {
+                    return;
+                }
+            }
+            setCurrentNamespace(namespace);
+            console.log(chalk.green(`Namespace set to "${namespace}"`));
+            return;
+        }
+        console.log(chalk.blue('Available config commands:'));
+        console.log('  get-context                  Display the current context');
+        console.log('  set-context --current --namespace=<namespace>  Set the current namespace');
+    }
+    catch (error) {
+        console.error(chalk.red(`Error: ${error}`));
+    }
+};

package/esm/commands/delete.js

@@ -0,0 +1,218 @@
+import chalk from 'chalk';
+import { KubernetesClient } from 'kubernetesjs';
+import { getCurrentNamespace, readYamlFile } from '../config';
+import * as fs from 'fs';
+async function promptResourceType(prompter, argv) {
+    const resourceTypes = [
+        'pod',
+        'service',
+        'deployment',
+        'replicaset',
+        'statefulset',
+        'daemonset',
+        'configmap',
+        'secret'
+    ];
+    const question = {
+        type: 'autocomplete',
+        name: 'resourceType',
+        message: 'Select resource type to delete',
+        options: resourceTypes,
+        maxDisplayLines: 10,
+        required: true
+    };
+    const { resourceType } = await prompter.prompt(argv, [question]);
+    return resourceType;
+}
+async function promptResourceSelection(prompter, argv, resourceType, namespace, client) {
+    let resources = [];
+    switch (resourceType) {
+        case 'pod':
+            const pods = await client.listCoreV1NamespacedPod({
+                path: { namespace },
+                query: { limit: 100 }
+            });
+            resources = pods.items || [];
+            break;
+        case 'service':
+            const services = await client.listCoreV1NamespacedService({
+                path: { namespace },
+                query: { limit: 100 }
+            });
+            resources = services.items || [];
+            break;
+        case 'deployment':
+            const deployments = await client.listAppsV1NamespacedDeployment({
+                path: { namespace },
+                query: { limit: 100 }
+            });
+            resources = deployments.items || [];
+            break;
+        case 'configmap':
+            const configmaps = await client.listCoreV1NamespacedConfigMap({
+                path: { namespace },
+                query: { limit: 100 }
+            });
+            resources = configmaps.items || [];
+            break;
+        case 'secret':
+            const secrets = await client.listCoreV1NamespacedSecret({
+                path: { namespace },
+                query: { limit: 100 }
+            });
+            resources = secrets.items || [];
+            break;
+        default:
+            console.log(chalk.yellow(`Resource type '${resourceType}' not implemented yet for selection`));
+            return [];
+    }
+    if (resources.length === 0) {
+        console.log(chalk.yellow(`No ${resourceType}s found in namespace ${namespace}`));
+        return [];
+    }
+    const options = resources.map(r => ({
+        name: r.metadata.name,
+        value: r.metadata.name
+    }));
+    const question = {
+        type: 'checkbox',
+        name: 'selectedResources',
+        message: `Select ${resourceType}(s) to delete`,
+        options,
+        maxDisplayLines: 10,
+        required: true
+    };
+    let selectedResources;
+    ({ selectedResources } = await prompter.prompt(argv, [question]));
+    return selectedResources
+        .filter(res => res.selected)
+        .map(res => res.value);
+}
+async function deleteResource(client, resourceType, resourceName, namespace) {
+    try {
+        switch (resourceType) {
+            case 'pod':
+                await client.deleteCoreV1NamespacedPod({
+                    path: {
+                        namespace,
+                        name: resourceName
+                    },
+                    query: {}
+                });
+                console.log(chalk.green(`Pod "${resourceName}" deleted successfully`));
+                break;
+            case 'service':
+                await client.deleteCoreV1NamespacedService({
+                    path: {
+                        namespace,
+                        name: resourceName
+                    },
+                    query: {}
+                });
+                console.log(chalk.green(`Service "${resourceName}" deleted successfully`));
+                break;
+            case 'deployment':
+                await client.deleteAppsV1NamespacedDeployment({
+                    path: {
+                        namespace,
+                        name: resourceName
+                    },
+                    query: {}
+                });
+                console.log(chalk.green(`Deployment "${resourceName}" deleted successfully`));
+                break;
+            case 'configmap':
+                await client.deleteCoreV1NamespacedConfigMap({
+                    path: {
+                        namespace,
+                        name: resourceName
+                    },
+                    query: {}
+                });
+                console.log(chalk.green(`ConfigMap "${resourceName}" deleted successfully`));
+                break;
+            case 'secret':
+                await client.deleteCoreV1NamespacedSecret({
+                    path: {
+                        namespace,
+                        name: resourceName
+                    },
+                    query: {}
+                });
+                console.log(chalk.green(`Secret "${resourceName}" deleted successfully`));
+                break;
+            default:
+                console.log(chalk.yellow(`Resource type '${resourceType}' not implemented yet for deletion`));
+        }
+    }
+    catch (error) {
+        console.error(chalk.red(`Error deleting ${resourceType} "${resourceName}": ${error}`));
+    }
+}
+async function deleteFromYaml(client, filePath, namespace) {
+    try {
+        const content = readYamlFile(filePath);
+        const resources = Array.isArray(content) ? content :
+            (content.kind === 'List' && Array.isArray(content.items)) ? content.items :
+                [content];
+        for (const resource of resources) {
+            const kind = resource.kind.toLowerCase();
+            const name = resource.metadata?.name;
+            const ns = resource.metadata?.namespace || namespace;
+            if (!name) {
+                console.error(chalk.red('Resource must have a name'));
+                continue;
+            }
+            await deleteResource(client, kind, name, ns);
+        }
+    }
+    catch (error) {
+        console.error(chalk.red(`Error processing YAML file: ${error}`));
+    }
+}
+export default async (argv, prompter, _options) => {
+    try {
+        const client = new KubernetesClient({
+            restEndpoint: 'http://localhost:8001' // Default kube-proxy endpoint
+        });
+        const namespace = argv.n || argv.namespace || getCurrentNamespace();
+        if (argv.f || argv.filename) {
+            const filePath = argv.f || argv.filename;
+            if (!fs.existsSync(filePath)) {
+                console.error(chalk.red(`File not found: ${filePath}`));
+                return;
+            }
+            await deleteFromYaml(client, filePath, namespace);
+            return;
+        }
+        const resourceType = argv._?.[0] || await promptResourceType(prompter, argv);
+        const resourceName = argv._?.[1];
+        if (resourceName) {
+            await deleteResource(client, resourceType, resourceName, namespace);
+        }
+        else {
+            const selectedResources = await promptResourceSelection(prompter, argv, resourceType, namespace, client);
+            if (selectedResources.length === 0) {
+                console.log(chalk.yellow('No resources selected for deletion'));
+                return;
+            }
+            const confirmQuestion = {
+                type: 'confirm',
+                name: 'confirmDelete',
+                message: `Are you sure you want to delete ${selectedResources.length} ${resourceType}(s)?`,
+                required: true
+            };
+            const { confirmDelete } = await prompter.prompt(argv, [confirmQuestion]);
+            if (!confirmDelete) {
+                console.log(chalk.yellow('Deletion cancelled'));
+                return;
+            }
+            for (const resource of selectedResources) {
+                await deleteResource(client, resourceType, resource, namespace);
+            }
+        }
+    }
+    catch (error) {
+        console.error(chalk.red(`Error: ${error}`));
+    }
+};