@kubernetesjs/cli 0.0.3 → 0.1.0

package/esm/commands/deploy.js

@@ -0,0 +1,207 @@
+import { KubernetesClient } from 'kubernetesjs';
+const createDeployment = (type) => {
+    const commonMetadata = {
+        name: `${type}-deployment`,
+        labels: {
+            app: type
+        }
+    };
+    const commonSpec = {
+        replicas: 1,
+        selector: {
+            matchLabels: {
+                app: type
+            }
+        },
+        template: {
+            metadata: {
+                labels: {
+                    app: type
+                }
+            }
+        }
+    };
+    switch (type) {
+        case 'minio':
+            return {
+                apiVersion: 'apps/v1',
+                kind: 'Deployment',
+                metadata: commonMetadata,
+                spec: {
+                    ...commonSpec,
+                    template: {
+                        ...commonSpec.template,
+                        spec: {
+                            containers: [{
+                                    name: 'minio',
+                                    image: 'minio/minio:latest',
+                                    ports: [{ containerPort: 9000, name: 'minio' }],
+                                    env: [
+                                        { name: 'MINIO_ROOT_USER', value: 'minioadmin' },
+                                        { name: 'MINIO_ROOT_PASSWORD', value: 'minioadmin' }
+                                    ],
+                                    args: ['server', '/data']
+                                }]
+                        }
+                    }
+                }
+            };
+        case 'postgres':
+            return {
+                apiVersion: 'apps/v1',
+                kind: 'Deployment',
+                metadata: commonMetadata,
+                spec: {
+                    ...commonSpec,
+                    template: {
+                        ...commonSpec.template,
+                        spec: {
+                            containers: [{
+                                    name: 'postgres',
+                                    image: 'pyramation/pgvector:13.3-alpine',
+                                    ports: [{ containerPort: 5432, name: 'postgres' }],
+                                    env: [
+                                        { name: 'POSTGRES_USER', value: 'postgres' },
+                                        { name: 'POSTGRES_PASSWORD', value: 'postgres' },
+                                        { name: 'POSTGRES_DB', value: 'postgres' }
+                                    ]
+                                }]
+                        }
+                    }
+                }
+            };
+        case 'ollama':
+            return {
+                apiVersion: 'apps/v1',
+                kind: 'Deployment',
+                metadata: commonMetadata,
+                spec: {
+                    ...commonSpec,
+                    template: {
+                        ...commonSpec.template,
+                        spec: {
+                            containers: [{
+                                    name: 'ollama',
+                                    image: 'ollama/ollama:latest',
+                                    ports: [{ containerPort: 11434, name: 'ollama' }]
+                                }]
+                        }
+                    }
+                }
+            };
+        default:
+            throw new Error(`Unsupported deployment type: ${type}`);
+    }
+};
+const createService = (type) => {
+    const commonMetadata = {
+        name: `${type}-service`,
+        labels: {
+            app: type
+        }
+    };
+    const commonSpec = {
+        selector: {
+            app: type
+        }
+    };
+    switch (type) {
+        case 'minio':
+            return {
+                apiVersion: 'v1',
+                kind: 'Service',
+                metadata: commonMetadata,
+                spec: {
+                    ...commonSpec,
+                    ports: [{ port: 9000, targetPort: 'minio' }],
+                    type: 'ClusterIP'
+                }
+            };
+        case 'postgres':
+            return {
+                apiVersion: 'v1',
+                kind: 'Service',
+                metadata: commonMetadata,
+                spec: {
+                    ...commonSpec,
+                    ports: [{ port: 5432, targetPort: 'postgres' }],
+                    type: 'ClusterIP'
+                }
+            };
+        case 'ollama':
+            return {
+                apiVersion: 'v1',
+                kind: 'Service',
+                metadata: commonMetadata,
+                spec: {
+                    ...commonSpec,
+                    ports: [{ port: 11434, targetPort: 'ollama' }],
+                    type: 'ClusterIP'
+                }
+            };
+        default:
+            throw new Error(`Unsupported service type: ${type}`);
+    }
+};
+export default async (argv, prompter, _options) => {
+    const deploymentOptions = ['minio', 'postgres', 'ollama'];
+    const questions = [
+        {
+            type: 'autocomplete',
+            name: 'deploymentType',
+            message: 'Select deployment type',
+            options: deploymentOptions,
+            maxDisplayLines: 5,
+            required: true
+        }
+    ];
+    const { deploymentType } = await prompter.prompt(argv, questions);
+    const confirmQuestion = {
+        type: 'confirm',
+        name: 'confirmDeployment',
+        message: `Are you sure you want to deploy ${deploymentType}?`,
+        required: true
+    };
+    const { confirmDeployment } = await prompter.prompt(argv, [confirmQuestion]);
+    if (!confirmDeployment) {
+        console.log('Deployment cancelled.');
+        return;
+    }
+    console.log(`Deploying ${deploymentType}...`);
+    try {
+        // Initialize Kubernetes client
+        const client = new KubernetesClient({
+            restEndpoint: argv.clientUrl
+        });
+        // Create deployment
+        const deployment = createDeployment(deploymentType);
+        await client.createAppsV1NamespacedDeployment({
+            path: {
+                namespace: 'default'
+            },
+            query: {
+                pretty: 'true'
+            },
+            body: deployment
+        });
+        console.log(`Created deployment: ${deployment.metadata.name}`);
+        // Create service
+        const service = createService(deploymentType);
+        await client.createCoreV1NamespacedService({
+            path: {
+                namespace: 'default'
+            },
+            query: {
+                pretty: 'true'
+            },
+            body: service
+        });
+        console.log(`Created service: ${service.metadata.name}`);
+        console.log(`Successfully deployed ${deploymentType}!`);
+    }
+    catch (error) {
+        console.error(`Failed to deploy ${deploymentType}:`, error);
+        throw error;
+    }
+    return { deploymentType };
+};

package/esm/commands/describe.js

@@ -0,0 +1,211 @@
+import chalk from 'chalk';
+import { KubernetesClient } from 'kubernetesjs';
+import { getCurrentNamespace } from '../config';
+async function promptResourceType(prompter, argv) {
+    const resourceTypes = [
+        'pod',
+        'service',
+        'deployment',
+        'replicaset',
+        'statefulset',
+        'daemonset',
+        'configmap',
+        'secret',
+        'namespace'
+    ];
+    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;
+}
+async function promptResourceName(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;
+        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: 'autocomplete',
+        name: 'resourceName',
+        message: `Select ${resourceType} name`,
+        options,
+        maxDisplayLines: 10,
+        required: true
+    };
+    const { resourceName } = await prompter.prompt(argv, [question]);
+    return resourceName;
+}
+function describePod(pod) {
+    console.log(chalk.bold(`Name:         ${pod.metadata.name}`));
+    console.log(chalk.bold(`Namespace:    ${pod.metadata.namespace}`));
+    console.log(chalk.bold(`Priority:     ${pod.spec.priority || 0}`));
+    console.log(chalk.bold(`Node:         ${pod.spec.nodeName || '<none>'}`));
+    console.log(chalk.bold(`Start Time:   ${pod.status.startTime || '<unknown>'}`));
+    console.log(chalk.bold('\nLabels:'));
+    if (pod.metadata.labels) {
+        Object.entries(pod.metadata.labels).forEach(([key, value]) => {
+            console.log(`  ${key}=${value}`);
+        });
+    }
+    console.log(chalk.bold('\nStatus:       ' + pod.status.phase));
+    console.log(chalk.bold('IP:           ' + pod.status.podIP));
+    console.log(chalk.bold('\nContainers:'));
+    if (pod.spec.containers) {
+        pod.spec.containers.forEach((container) => {
+            console.log(chalk.bold(`  ${container.name}:`));
+            console.log(`    Image:      ${container.image}`);
+            console.log(`    Ports:      ${container.ports?.map((p) => p.containerPort).join(', ') || '<none>'}`);
+            const status = pod.status.containerStatuses?.find((s) => s.name === container.name);
+            if (status) {
+                console.log(`    Ready:      ${status.ready}`);
+                console.log(`    Restarts:   ${status.restartCount}`);
+                const stateEntries = Object.entries(status.state || {});
+                if (stateEntries.length > 0) {
+                    const [state, details] = stateEntries[0];
+                    console.log(`    State:      ${state}`);
+                    if (details && typeof details === 'object') {
+                        Object.entries(details).forEach(([key, value]) => {
+                            console.log(`      ${key}: ${value}`);
+                        });
+                    }
+                }
+            }
+            console.log('');
+        });
+    }
+    console.log(chalk.bold('Events:'));
+    console.log('  <Events not available in this implementation>');
+}
+function describeService(service) {
+    console.log(chalk.bold(`Name:              ${service.metadata.name}`));
+    console.log(chalk.bold(`Namespace:         ${service.metadata.namespace}`));
+    console.log(chalk.bold(`Labels:            ${JSON.stringify(service.metadata.labels || {})}`));
+    console.log(chalk.bold(`Selector:          ${JSON.stringify(service.spec.selector || {})}`));
+    console.log(chalk.bold(`Type:              ${service.spec.type}`));
+    console.log(chalk.bold(`IP:                ${service.spec.clusterIP}`));
+    if (service.spec.ports) {
+        console.log(chalk.bold('\nPorts:'));
+        service.spec.ports.forEach((port) => {
+            console.log(`  ${port.name || '<unnamed>'}: ${port.port}/${port.protocol} -> ${port.targetPort}`);
+        });
+    }
+    console.log(chalk.bold('\nSession Affinity: ' + (service.spec.sessionAffinity || 'None')));
+    console.log(chalk.bold('\nEvents:'));
+    console.log('  <Events not available in this implementation>');
+}
+function describeDeployment(deployment) {
+    console.log(chalk.bold(`Name:               ${deployment.metadata.name}`));
+    console.log(chalk.bold(`Namespace:          ${deployment.metadata.namespace}`));
+    console.log(chalk.bold(`CreationTimestamp:  ${deployment.metadata.creationTimestamp}`));
+    console.log(chalk.bold(`Labels:             ${JSON.stringify(deployment.metadata.labels || {})}`));
+    console.log(chalk.bold(`Annotations:        ${JSON.stringify(deployment.metadata.annotations || {})}`));
+    console.log(chalk.bold(`Selector:           ${JSON.stringify(deployment.spec.selector.matchLabels || {})}`));
+    console.log(chalk.bold(`Replicas:           ${deployment.status.replicas || 0} desired | ${deployment.status.updatedReplicas || 0} updated | ${deployment.status.readyReplicas || 0} ready | ${deployment.status.availableReplicas || 0} available`));
+    console.log(chalk.bold(`StrategyType:       ${deployment.spec.strategy.type}`));
+    if (deployment.spec.template && deployment.spec.template.spec.containers) {
+        console.log(chalk.bold('\nContainers:'));
+        deployment.spec.template.spec.containers.forEach((container) => {
+            console.log(chalk.bold(`  ${container.name}:`));
+            console.log(`    Image:      ${container.image}`);
+            console.log(`    Ports:      ${container.ports?.map((p) => p.containerPort).join(', ') || '<none>'}`);
+            console.log(`    Environment: ${container.env?.map((e) => `${e.name}=${e.value}`).join(', ') || '<none>'}`);
+            console.log('');
+        });
+    }
+    if (deployment.status.conditions) {
+        console.log(chalk.bold('\nConditions:'));
+        console.log(chalk.bold('  Type           Status  Reason'));
+        deployment.status.conditions.forEach((condition) => {
+            console.log(`  ${condition.type.padEnd(15)}${condition.status.padEnd(8)}${condition.reason || ''}`);
+        });
+    }
+    console.log(chalk.bold('\nEvents:'));
+    console.log('  <Events not available in this implementation>');
+}
+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();
+        const resourceType = argv._?.[0] || await promptResourceType(prompter, argv);
+        const resourceName = argv._?.[1] || await promptResourceName(prompter, argv, resourceType, namespace, client);
+        if (!resourceName) {
+            return;
+        }
+        console.log(chalk.blue(`Describing ${resourceType} ${resourceName} in namespace ${namespace}...`));
+        switch (resourceType) {
+            case 'pod':
+                const pod = await client.readCoreV1NamespacedPod({
+                    path: {
+                        namespace,
+                        name: resourceName
+                    },
+                    query: {}
+                });
+                describePod(pod);
+                break;
+            case 'service':
+                const service = await client.readCoreV1NamespacedService({
+                    path: {
+                        namespace,
+                        name: resourceName
+                    },
+                    query: {}
+                });
+                describeService(service);
+                break;
+            case 'deployment':
+                const deployment = await client.readAppsV1NamespacedDeployment({
+                    path: {
+                        namespace,
+                        name: resourceName
+                    },
+                    query: {}
+                });
+                describeDeployment(deployment);
+                break;
+            default:
+                console.log(chalk.yellow(`Resource type '${resourceType}' not implemented yet`));
+        }
+    }
+    catch (error) {
+        console.error(chalk.red(`Error: ${error}`));
+    }
+};

package/esm/commands/exec.js

@@ -0,0 +1,140 @@
+import chalk from 'chalk';
+import { KubernetesClient } from 'kubernetesjs';
+import { getCurrentNamespace } from '../config';
+import { spawn } from 'child_process';
+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 '';
+    }
+}
+async function execInPod(namespace, podName, containerName, command) {
+    console.log(chalk.blue(`Executing command in ${containerName ? 'container ' + containerName + ' of ' : ''}pod ${podName} in namespace ${namespace}...`));
+    const kubectlArgs = [
+        'exec',
+        '-it',
+        '-n', namespace,
+        podName
+    ];
+    if (containerName) {
+        kubectlArgs.push('-c', containerName);
+    }
+    kubectlArgs.push('--', ...command);
+    const kubectl = spawn('kubectl', kubectlArgs, {
+        stdio: 'inherit',
+        shell: true
+    });
+    return new Promise((resolve, reject) => {
+        kubectl.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`kubectl exec 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();
+        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;
+            }
+        }
+        let command = [];
+        const dashIndex = argv._.findIndex(arg => arg === '--');
+        if (dashIndex !== -1 && dashIndex < argv._.length - 1) {
+            command = argv._.slice(dashIndex + 1);
+        }
+        else {
+            const commandQuestion = {
+                type: 'text',
+                name: 'command',
+                message: 'Enter command to execute',
+                required: true,
+                default: '/bin/sh',
+                useDefault: true
+            };
+            const { command: cmd } = await prompter.prompt(argv, [commandQuestion]);
+            command = cmd.split(' ');
+        }
+        await execInPod(namespace, podName, containerName, command);
+    }
+    catch (error) {
+        console.error(chalk.red(`Error: ${error}`));
+    }
+};