@kubernetesjs/cli 0.0.3 → 0.1.0

package/esm/commands/get.js

@@ -0,0 +1,159 @@
+import chalk from 'chalk';
+import { KubernetesClient } from 'kubernetesjs';
+import { getCurrentNamespace } from '../config';
+async function promptResourceType(prompter, argv) {
+    const resourceTypes = [
+        'pods',
+        'services',
+        'deployments',
+        'replicasets',
+        'statefulsets',
+        'daemonsets',
+        'configmaps',
+        'secrets',
+        'namespaces',
+        'all'
+    ];
+    const question = {
+        type: 'autocomplete',
+        name: 'resourceType',
+        message: 'Select resource type',
+        options: resourceTypes,
+        maxDisplayLines: 10,
+        required: true
+    };
+    const { resourceType } = await prompter.prompt(argv, [question]);
+    return resourceType;
+}
+function formatPodData(pod) {
+    const name = pod.metadata.name;
+    const ready = `${pod.status.containerStatuses?.filter((c) => c.ready).length || 0}/${pod.status.containerStatuses?.length || 0}`;
+    const status = pod.status.phase;
+    const restarts = pod.status.containerStatuses?.reduce((sum, c) => sum + c.restartCount, 0) || 0;
+    const age = new Date(pod.metadata.creationTimestamp).toLocaleString();
+    console.log(chalk.green(name.padEnd(50)) +
+        ready.padEnd(10) +
+        status.padEnd(15) +
+        restarts.toString().padEnd(10) +
+        age);
+}
+function formatServiceData(service) {
+    const name = service.metadata.name;
+    const type = service.spec.type;
+    const clusterIP = service.spec.clusterIP;
+    const externalIP = service.spec.externalIPs?.join(',') || '<none>';
+    const ports = service.spec.ports?.map((p) => `${p.port}:${p.targetPort}`).join(',') || '<none>';
+    const age = new Date(service.metadata.creationTimestamp).toLocaleString();
+    console.log(chalk.green(name.padEnd(30)) +
+        type.padEnd(15) +
+        clusterIP.padEnd(20) +
+        externalIP.padEnd(20) +
+        ports.padEnd(20) +
+        age);
+}
+function formatDeploymentData(deployment) {
+    const name = deployment.metadata.name;
+    const ready = `${deployment.status.readyReplicas || 0}/${deployment.status.replicas || 0}`;
+    const upToDate = deployment.status.updatedReplicas || 0;
+    const available = deployment.status.availableReplicas || 0;
+    const age = new Date(deployment.metadata.creationTimestamp).toLocaleString();
+    console.log(chalk.green(name.padEnd(30)) +
+        ready.padEnd(10) +
+        upToDate.toString().padEnd(10) +
+        available.toString().padEnd(10) +
+        age);
+}
+async function getAllResources(client, namespace) {
+    try {
+        const pods = await client.listCoreV1NamespacedPod({
+            path: { namespace },
+            query: { limit: 100 }
+        });
+        if (pods.items && pods.items.length > 0) {
+            console.log(chalk.bold('\nPODS:'));
+            console.log(chalk.bold('NAME'.padEnd(50) + 'READY'.padEnd(10) + 'STATUS'.padEnd(15) + 'RESTARTS'.padEnd(10) + 'AGE'));
+            pods.items.forEach(formatPodData);
+        }
+        const services = await client.listCoreV1NamespacedService({
+            path: { namespace },
+            query: { limit: 100 }
+        });
+        if (services.items && services.items.length > 0) {
+            console.log(chalk.bold('\nSERVICES:'));
+            console.log(chalk.bold('NAME'.padEnd(30) + 'TYPE'.padEnd(15) + 'CLUSTER-IP'.padEnd(20) + 'EXTERNAL-IP'.padEnd(20) + 'PORT(S)'.padEnd(20) + 'AGE'));
+            services.items.forEach(formatServiceData);
+        }
+        const deployments = await client.listAppsV1NamespacedDeployment({
+            path: { namespace },
+            query: { limit: 100 }
+        });
+        if (deployments.items && deployments.items.length > 0) {
+            console.log(chalk.bold('\nDEPLOYMENTS:'));
+            console.log(chalk.bold('NAME'.padEnd(30) + 'READY'.padEnd(10) + 'UP-TO-DATE'.padEnd(10) + 'AVAILABLE'.padEnd(10) + 'AGE'));
+            deployments.items.forEach(formatDeploymentData);
+        }
+    }
+    catch (error) {
+        console.error(chalk.red(`Error getting resources: ${error}`));
+    }
+}
+export default async (argv, prompter, _options) => {
+    try {
+        const client = new KubernetesClient({
+            restEndpoint: argv.clientUrl
+        });
+        const namespace = argv.n || argv.namespace || getCurrentNamespace();
+        const resourceType = argv._?.[0] || await promptResourceType(prompter, argv);
+        console.log(chalk.blue(`Getting ${resourceType} in namespace ${namespace}...`));
+        if (resourceType === 'all') {
+            await getAllResources(client, namespace);
+            return;
+        }
+        switch (resourceType) {
+            case 'pods':
+                const pods = await client.listCoreV1NamespacedPod({
+                    path: { namespace },
+                    query: { limit: 100 }
+                });
+                console.log(chalk.bold('NAME'.padEnd(50) + 'READY'.padEnd(10) + 'STATUS'.padEnd(15) + 'RESTARTS'.padEnd(10) + 'AGE'));
+                if (pods.items && pods.items.length > 0) {
+                    pods.items.forEach(formatPodData);
+                }
+                else {
+                    console.log(chalk.yellow('No pods found'));
+                }
+                break;
+            case 'services':
+                const services = await client.listCoreV1NamespacedService({
+                    path: { namespace },
+                    query: { limit: 100 }
+                });
+                console.log(chalk.bold('NAME'.padEnd(30) + 'TYPE'.padEnd(15) + 'CLUSTER-IP'.padEnd(20) + 'EXTERNAL-IP'.padEnd(20) + 'PORT(S)'.padEnd(20) + 'AGE'));
+                if (services.items && services.items.length > 0) {
+                    services.items.forEach(formatServiceData);
+                }
+                else {
+                    console.log(chalk.yellow('No services found'));
+                }
+                break;
+            case 'deployments':
+                const deployments = await client.listAppsV1NamespacedDeployment({
+                    path: { namespace },
+                    query: { limit: 100 }
+                });
+                console.log(chalk.bold('NAME'.padEnd(30) + 'READY'.padEnd(10) + 'UP-TO-DATE'.padEnd(10) + 'AVAILABLE'.padEnd(10) + 'AGE'));
+                if (deployments.items && deployments.items.length > 0) {
+                    deployments.items.forEach(formatDeploymentData);
+                }
+                else {
+                    console.log(chalk.yellow('No deployments found'));
+                }
+                break;
+            default:
+                console.log(chalk.yellow(`Resource type '${resourceType}' not implemented yet`));
+        }
+    }
+    catch (error) {
+        console.error(chalk.red(`Error: ${error}`));
+    }
+};

package/esm/commands/logs.js

@@ -0,0 +1,105 @@
+import chalk from 'chalk';
+import { KubernetesClient } from 'kubernetesjs';
+import { getCurrentNamespace } from '../config';
+async function promptPodName(prompter, argv, namespace, client) {
+    try {
+        const pods = await client.listCoreV1NamespacedPod({
+            path: { namespace },
+            query: { limit: 100 }
+        });
+        if (!pods.items || pods.items.length === 0) {
+            console.log(chalk.yellow(`No pods found in namespace ${namespace}`));
+            return '';
+        }
+        const options = pods.items.map(pod => ({
+            name: pod.metadata.name,
+            value: pod.metadata.name
+        }));
+        const question = {
+            type: 'autocomplete',
+            name: 'podName',
+            message: 'Select pod',
+            options,
+            maxDisplayLines: 10,
+            required: true
+        };
+        const { podName } = await prompter.prompt(argv, [question]);
+        return podName;
+    }
+    catch (error) {
+        console.error(chalk.red(`Error getting pods: ${error}`));
+        return '';
+    }
+}
+async function promptContainerName(prompter, argv, namespace, podName, client) {
+    try {
+        const pod = await client.readCoreV1NamespacedPod({
+            path: {
+                namespace,
+                name: podName
+            },
+            query: {}
+        });
+        if (!pod.spec || !pod.spec.containers || pod.spec.containers.length === 0) {
+            console.log(chalk.yellow(`No containers found in pod ${podName}`));
+            return '';
+        }
+        if (pod.spec.containers.length === 1) {
+            return pod.spec.containers[0].name;
+        }
+        const options = pod.spec.containers.map(container => ({
+            name: container.name,
+            value: container.name
+        }));
+        const question = {
+            type: 'autocomplete',
+            name: 'containerName',
+            message: 'Select container',
+            options,
+            maxDisplayLines: 10,
+            required: true
+        };
+        const { containerName } = await prompter.prompt(argv, [question]);
+        return containerName;
+    }
+    catch (error) {
+        console.error(chalk.red(`Error getting containers: ${error}`));
+        return '';
+    }
+}
+export default async (argv, prompter, _options) => {
+    try {
+        const client = new KubernetesClient({
+            restEndpoint: argv.clientUrl
+        });
+        const namespace = argv.n || argv.namespace || getCurrentNamespace();
+        const podName = argv._?.[0] || await promptPodName(prompter, argv, namespace, client);
+        if (!podName) {
+            return;
+        }
+        let containerName = argv.c || argv.container;
+        if (!containerName) {
+            containerName = await promptContainerName(prompter, argv, namespace, podName, client);
+            if (!containerName) {
+                return;
+            }
+        }
+        console.log(chalk.blue(`Getting logs for ${containerName ? 'container ' + containerName + ' in ' : ''}pod ${podName} in namespace ${namespace}...`));
+        const logs = await client.readCoreV1NamespacedPodLog({
+            path: {
+                namespace,
+                name: podName
+            },
+            query: {
+                container: containerName,
+                tailLines: argv.tail ? parseInt(argv.tail, 10) : undefined,
+                follow: false,
+                previous: argv.previous === true
+            }
+        });
+        console.log(logs);
+    }
+    catch (error) {
+        console.error(chalk.red(`Error: ${error}`));
+    }
+};

package/esm/commands/port-forward.js

@@ -0,0 +1,138 @@
+import chalk from 'chalk';
+import { KubernetesClient } from 'kubernetesjs';
+import { getCurrentNamespace } from '../config';
+import { spawn } from 'child_process';
+async function promptServiceName(prompter, argv, namespace, client) {
+    try {
+        const services = await client.listCoreV1NamespacedService({
+            path: { namespace },
+            query: { limit: 100 }
+        });
+        if (!services.items || services.items.length === 0) {
+            console.log(chalk.yellow(`No services found in namespace ${namespace}`));
+            return '';
+        }
+        const options = services.items.map(service => ({
+            name: service.metadata.name,
+            value: service.metadata.name
+        }));
+        const question = {
+            type: 'autocomplete',
+            name: 'serviceName',
+            message: 'Select service',
+            options,
+            maxDisplayLines: 10,
+            required: true
+        };
+        const { serviceName } = await prompter.prompt(argv, [question]);
+        return serviceName;
+    }
+    catch (error) {
+        console.error(chalk.red(`Error getting services: ${error}`));
+        return '';
+    }
+}
+async function promptPortMapping(prompter, argv, namespace, serviceName, client) {
+    try {
+        const service = await client.readCoreV1NamespacedService({
+            path: {
+                namespace,
+                name: serviceName
+            },
+            query: {}
+        });
+        if (!service.spec || !service.spec.ports || service.spec.ports.length === 0) {
+            console.log(chalk.yellow(`No ports found in service ${serviceName}`));
+            return '';
+        }
+        if (service.spec.ports.length === 1) {
+            const port = service.spec.ports[0];
+            const localPort = port.port;
+            const remotePort = port.targetPort || port.port;
+            const confirmQuestion = {
+                type: 'confirm',
+                name: 'confirmPortMapping',
+                message: `Use port mapping ${localPort}:${remotePort}?`,
+                required: true
+            };
+            const { confirmPortMapping } = await prompter.prompt(argv, [confirmQuestion]);
+            if (confirmPortMapping) {
+                return `${localPort}:${remotePort}`;
+            }
+        }
+        const portMappingQuestion = {
+            type: 'text',
+            name: 'portMapping',
+            message: 'Enter port mapping (local:remote)',
+            required: true
+        };
+        const { portMapping } = await prompter.prompt(argv, [portMappingQuestion]);
+        return portMapping;
+    }
+    catch (error) {
+        console.error(chalk.red(`Error getting service ports: ${error}`));
+        return '';
+    }
+}
+async function portForward(namespace, resourceType, resourceName, portMapping) {
+    console.log(chalk.blue(`Forwarding ports ${portMapping} to ${resourceType}/${resourceName} in namespace ${namespace}...`));
+    console.log(chalk.yellow('Press Ctrl+C to stop port forwarding'));
+    const kubectlArgs = [
+        'port-forward',
+        '-n', namespace,
+        `${resourceType}/${resourceName}`,
+        portMapping
+    ];
+    const kubectl = spawn('kubectl', kubectlArgs, {
+        stdio: 'inherit',
+        shell: true
+    });
+    return new Promise((resolve, reject) => {
+        kubectl.on('close', (code) => {
+            if (code === 0 || code === 130) { // 130 is the exit code when terminated by Ctrl+C
+                resolve();
+            }
+            else {
+                reject(new Error(`kubectl port-forward exited with code ${code}`));
+            }
+        });
+        kubectl.on('error', (error) => {
+            reject(error);
+        });
+    });
+}
+export default async (argv, prompter, _options) => {
+    try {
+        const client = new KubernetesClient({
+            restEndpoint: argv.clientUrl
+        });
+        const namespace = argv.n || argv.namespace || getCurrentNamespace();
+        let resourceType = 'svc';
+        let resourceName = '';
+        if (argv._?.[0]) {
+            const resourceArg = argv._[0];
+            if (resourceArg.includes('/')) {
+                const [type, name] = resourceArg.split('/');
+                resourceType = type;
+                resourceName = name;
+            }
+            else {
+                resourceName = resourceArg;
+            }
+        }
+        if (!resourceName) {
+            resourceName = await promptServiceName(prompter, argv, namespace, client);
+            if (!resourceName) {
+                return;
+            }
+        }
+        const portMapping = argv._?.[1] || await promptPortMapping(prompter, argv, namespace, resourceName, client);
+        if (!portMapping) {
+            return;
+        }
+        await portForward(namespace, resourceType, resourceName, portMapping);
+    }
+    catch (error) {
+        console.error(chalk.red(`Error: ${error}`));
+    }
+};

package/esm/commands.js

@@ -0,0 +1,86 @@
+import { readAndParsePackageJson } from './package';
+import { extractFirst, usageText } from './utils';
+// Commands
+import deploy from './commands/deploy';
+import get from './commands/get';
+import describe from './commands/describe';
+import logs from './commands/logs';
+import apply from './commands/apply';
+import deleteCmd from './commands/delete';
+import exec from './commands/exec';
+import portForward from './commands/port-forward';
+import clusterInfo from './commands/cluster-info';
+import config from './commands/config';
+const commandMap = {
+    deploy,
+    get,
+    describe,
+    logs,
+    apply,
+    delete: deleteCmd,
+    exec,
+    'port-forward': portForward,
+    'cluster-info': clusterInfo,
+    config
+};
+import configHandler from './commands/config-handler';
+export const commands = async (argv, prompter, options) => {
+    if (argv.version || argv.v) {
+        const pkg = readAndParsePackageJson();
+        console.log(pkg.version);
+        process.exit(0);
+    }
+    if (argv.config) {
+        const handled = await configHandler(argv, prompter, options, commandMap);
+        if (handled) {
+            prompter.close();
+            return argv;
+        }
+    }
+    let { first: command, newArgv } = extractFirst(argv);
+    // Show usage if explicitly requested
+    if (argv.help || argv.h || command === 'help') {
+        console.log(usageText);
+        process.exit(0);
+    }
+    // Prompt if no command provided
+    if (!command) {
+        const answer = await prompter.prompt(argv, [
+            {
+                type: 'autocomplete',
+                name: 'command',
+                message: 'What do you want to do?',
+                options: Object.keys(commandMap)
+            }
+        ]);
+        command = answer.command;
+    }
+    // Prompt for working directory and client URL
+    newArgv = await prompter.prompt(newArgv, [
+        {
+            type: 'text',
+            name: 'cwd',
+            message: 'Working directory',
+            required: false,
+            default: process.cwd(),
+            useDefault: true
+        },
+        {
+            type: 'text',
+            name: 'clientUrl',
+            message: 'Kubernetes API URL',
+            required: false,
+            default: 'http://127.0.0.1:8001',
+            useDefault: true
+        }
+    ]);
+    const commandFn = commandMap[command];
+    if (!commandFn) {
+        console.error(`Unknown command: ${command}`);
+        console.log(usageText);
+        process.exit(1);
+    }
+    await commandFn(newArgv, prompter, options);
+    prompter.close();
+    return argv;
+};

package/esm/config.js

@@ -0,0 +1,74 @@
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import * as yaml from 'js-yaml';
+const KUBECONFIG_PATH = join(homedir(), '.kubeconfig');
+const DEFAULT_NAMESPACE = 'default';
+/**
+ * Read and parse a YAML file
+ * @param filePath Path to the YAML file
+ * @returns Parsed YAML content
+ */
+export function readYamlFile(filePath) {
+    try {
+        const fileContent = 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)
+ */
+export 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
+ */
+export function getCurrentNamespace() {
+    try {
+        if (!existsSync(KUBECONFIG_PATH)) {
+            return DEFAULT_NAMESPACE;
+        }
+        const configContent = 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
+ */
+export function setCurrentNamespace(namespace) {
+    try {
+        let config = { currentNamespace: namespace };
+        if (existsSync(KUBECONFIG_PATH)) {
+            try {
+                const configContent = readFileSync(KUBECONFIG_PATH, 'utf8');
+                config = { ...JSON.parse(configContent), currentNamespace: namespace };
+            }
+            catch (error) {
+                console.error(`Error parsing existing kubeconfig: ${error}`);
+            }
+        }
+        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/index.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import { CLI } from 'inquirerer';
+import { commands } from './commands';
+export const options = {
+    minimistOpts: {
+        alias: {
+            v: 'version',
+            h: 'help',
+            c: 'clientUrl'
+        }
+    }
+};
+const app = new CLI(commands, options);
+app.run().then(() => {
+    // all done!
+}).catch(error => {
+    console.error(error);
+    process.exit(1);
+});

package/esm/package.js

@@ -0,0 +1,26 @@
+import { existsSync, readFileSync } from 'fs';
+import { dirname, join } from 'path';
+// need to search due to the dist/ folder and src/, etc.
+function findPackageJson(currentDir) {
+    const filePath = join(currentDir, 'package.json');
+    // Check if package.json exists in the current directory
+    if (existsSync(filePath)) {
+        return filePath;
+    }
+    // Get the parent directory
+    const parentDir = dirname(currentDir);
+    // If reached the root directory, package.json is not found
+    if (parentDir === currentDir) {
+        throw new Error('package.json not found in any parent directory');
+    }
+    // Recursively look in the parent directory
+    return findPackageJson(parentDir);
+}
+export function readAndParsePackageJson() {
+    // Start searching from the current directory
+    const pkgPath = findPackageJson(__dirname);
+    // Read and parse the package.json
+    const str = readFileSync(pkgPath, 'utf8');
+    const pkg = JSON.parse(str);
+    return pkg;
+}

package/esm/utils.js

@@ -0,0 +1,49 @@
+import chalk from 'chalk';
+import { readAndParsePackageJson } from './package';
+export const extractFirst = (argv) => {
+    const first = argv._?.[0];
+    const newArgv = {
+        ...argv,
+        _: argv._?.slice(1) ?? []
+    };
+    return { first, newArgv };
+};
+// Function to display the version information
+export function displayVersion() {
+    const pkg = readAndParsePackageJson();
+    console.log(chalk.green(`Name: ${pkg.name}`));
+    console.log(chalk.blue(`Version: ${pkg.version}`));
+}
+export const usageText = `
+  Usage: k8s <command> [options]
+  
+  Commands:
+    get [resource]         List resources (pods, services, deployments, etc.)
+    describe [resource]    Show detailed information about a specific resource
+    logs [pod]             Display logs from a container in a pod
+    exec [pod] -- [cmd]    Execute a command in a container
+    apply -f [file]        Apply a configuration to a resource by file name
+    delete [resource]      Delete resources
+    port-forward [svc]     Forward one or more local ports to a pod
+    cluster-info           Display cluster information
+    config                 Modify kubeconfig files
+    deploy                 Deploy a container to Kubernetes
+    version, -v            Display the version of the CLI
+  
+  Configuration File:
+    --config <path>        Specify the path to a YAML configuration file.
+                           Command-line options will override settings from this file if both are provided.
+  
+  Namespace:
+    -n, --namespace        Specify the namespace to use. Default is from local config or "default".
+  
+  Additional Options:
+    -c, --clientUrl <url>  Specify the Kubernetes API endpoint URL.
+                           Default is http://127.0.0.1:8001 (kubectl proxy)
+  
+  Additional Help:
+    $ k8s help             Display this help information.
+  `;
+export function displayUsage() {
+    console.log(usageText);
+}

package/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { CLIOptions } from 'inquirerer';
+export declare const options: Partial<CLIOptions>;

package/index.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.options = void 0;
+const inquirerer_1 = require("inquirerer");
+const commands_1 = require("./commands");
+exports.options = {
+    minimistOpts: {
+        alias: {
+            v: 'version',
+            h: 'help',
+            c: 'clientUrl'
+        }
+    }
+};
+const app = new inquirerer_1.CLI(commands_1.commands, exports.options);
+app.run().then(() => {
+    // all done!
+}).catch(error => {
+    console.error(error);
+    process.exit(1);
+});

package/package.d.ts

@@ -0,0 +1 @@
+export declare function readAndParsePackageJson(): any;