@kubernetesjs/cli 0.0.3 → 0.1.0

package/commands/delete.js

@@ -0,0 +1,256 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+const kubernetesjs_1 = require("kubernetesjs");
+const config_1 = require("../config");
+const fs = __importStar(require("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_1.default.yellow(`Resource type '${resourceType}' not implemented yet for selection`));
+            return [];
+    }
+    if (resources.length === 0) {
+        console.log(chalk_1.default.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_1.default.green(`Pod "${resourceName}" deleted successfully`));
+                break;
+            case 'service':
+                await client.deleteCoreV1NamespacedService({
+                    path: {
+                        namespace,
+                        name: resourceName
+                    },
+                    query: {}
+                });
+                console.log(chalk_1.default.green(`Service "${resourceName}" deleted successfully`));
+                break;
+            case 'deployment':
+                await client.deleteAppsV1NamespacedDeployment({
+                    path: {
+                        namespace,
+                        name: resourceName
+                    },
+                    query: {}
+                });
+                console.log(chalk_1.default.green(`Deployment "${resourceName}" deleted successfully`));
+                break;
+            case 'configmap':
+                await client.deleteCoreV1NamespacedConfigMap({
+                    path: {
+                        namespace,
+                        name: resourceName
+                    },
+                    query: {}
+                });
+                console.log(chalk_1.default.green(`ConfigMap "${resourceName}" deleted successfully`));
+                break;
+            case 'secret':
+                await client.deleteCoreV1NamespacedSecret({
+                    path: {
+                        namespace,
+                        name: resourceName
+                    },
+                    query: {}
+                });
+                console.log(chalk_1.default.green(`Secret "${resourceName}" deleted successfully`));
+                break;
+            default:
+                console.log(chalk_1.default.yellow(`Resource type '${resourceType}' not implemented yet for deletion`));
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`Error deleting ${resourceType} "${resourceName}": ${error}`));
+    }
+}
+async function deleteFromYaml(client, filePath, namespace) {
+    try {
+        const content = (0, config_1.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_1.default.red('Resource must have a name'));
+                continue;
+            }
+            await deleteResource(client, kind, name, ns);
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`Error processing YAML file: ${error}`));
+    }
+}
+exports.default = async (argv, prompter, _options) => {
+    try {
+        const client = new kubernetesjs_1.KubernetesClient({
+            restEndpoint: 'http://localhost:8001' // Default kube-proxy endpoint
+        });
+        const namespace = argv.n || argv.namespace || (0, config_1.getCurrentNamespace)();
+        if (argv.f || argv.filename) {
+            const filePath = argv.f || argv.filename;
+            if (!fs.existsSync(filePath)) {
+                console.error(chalk_1.default.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_1.default.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_1.default.yellow('Deletion cancelled'));
+                return;
+            }
+            for (const resource of selectedResources) {
+                await deleteResource(client, resourceType, resource, namespace);
+            }
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`Error: ${error}`));
+    }
+};

package/commands/deploy.d.ts

@@ -0,0 +1,6 @@
+import { CLIOptions, Inquirerer } from 'inquirerer';
+import { ParsedArgs } from 'minimist';
+declare const _default: (argv: Partial<ParsedArgs>, prompter: Inquirerer, _options: CLIOptions) => Promise<{
+    deploymentType: any;
+}>;
+export default _default;

package/commands/deploy.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const kubernetesjs_1 = require("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}`);
+    }
+};
+exports.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 kubernetesjs_1.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/commands/describe.d.ts

@@ -0,0 +1,4 @@
+import { CLIOptions, Inquirerer } from 'inquirerer';
+import { ParsedArgs } from 'minimist';
+declare const _default: (argv: Partial<ParsedArgs>, prompter: Inquirerer, _options: CLIOptions) => Promise<void>;
+export default _default;

package/commands/describe.js

@@ -0,0 +1,216 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+const kubernetesjs_1 = require("kubernetesjs");
+const config_1 = require("../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_1.default.yellow(`Resource type '${resourceType}' not implemented yet for selection`));
+            return '';
+    }
+    if (resources.length === 0) {
+        console.log(chalk_1.default.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_1.default.bold(`Name:         ${pod.metadata.name}`));
+    console.log(chalk_1.default.bold(`Namespace:    ${pod.metadata.namespace}`));
+    console.log(chalk_1.default.bold(`Priority:     ${pod.spec.priority || 0}`));
+    console.log(chalk_1.default.bold(`Node:         ${pod.spec.nodeName || '<none>'}`));
+    console.log(chalk_1.default.bold(`Start Time:   ${pod.status.startTime || '<unknown>'}`));
+    console.log(chalk_1.default.bold('\nLabels:'));
+    if (pod.metadata.labels) {
+        Object.entries(pod.metadata.labels).forEach(([key, value]) => {
+            console.log(`  ${key}=${value}`);
+        });
+    }
+    console.log(chalk_1.default.bold('\nStatus:       ' + pod.status.phase));
+    console.log(chalk_1.default.bold('IP:           ' + pod.status.podIP));
+    console.log(chalk_1.default.bold('\nContainers:'));
+    if (pod.spec.containers) {
+        pod.spec.containers.forEach((container) => {
+            console.log(chalk_1.default.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_1.default.bold('Events:'));
+    console.log('  <Events not available in this implementation>');
+}
+function describeService(service) {
+    console.log(chalk_1.default.bold(`Name:              ${service.metadata.name}`));
+    console.log(chalk_1.default.bold(`Namespace:         ${service.metadata.namespace}`));
+    console.log(chalk_1.default.bold(`Labels:            ${JSON.stringify(service.metadata.labels || {})}`));
+    console.log(chalk_1.default.bold(`Selector:          ${JSON.stringify(service.spec.selector || {})}`));
+    console.log(chalk_1.default.bold(`Type:              ${service.spec.type}`));
+    console.log(chalk_1.default.bold(`IP:                ${service.spec.clusterIP}`));
+    if (service.spec.ports) {
+        console.log(chalk_1.default.bold('\nPorts:'));
+        service.spec.ports.forEach((port) => {
+            console.log(`  ${port.name || '<unnamed>'}: ${port.port}/${port.protocol} -> ${port.targetPort}`);
+        });
+    }
+    console.log(chalk_1.default.bold('\nSession Affinity: ' + (service.spec.sessionAffinity || 'None')));
+    console.log(chalk_1.default.bold('\nEvents:'));
+    console.log('  <Events not available in this implementation>');
+}
+function describeDeployment(deployment) {
+    console.log(chalk_1.default.bold(`Name:               ${deployment.metadata.name}`));
+    console.log(chalk_1.default.bold(`Namespace:          ${deployment.metadata.namespace}`));
+    console.log(chalk_1.default.bold(`CreationTimestamp:  ${deployment.metadata.creationTimestamp}`));
+    console.log(chalk_1.default.bold(`Labels:             ${JSON.stringify(deployment.metadata.labels || {})}`));
+    console.log(chalk_1.default.bold(`Annotations:        ${JSON.stringify(deployment.metadata.annotations || {})}`));
+    console.log(chalk_1.default.bold(`Selector:           ${JSON.stringify(deployment.spec.selector.matchLabels || {})}`));
+    console.log(chalk_1.default.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_1.default.bold(`StrategyType:       ${deployment.spec.strategy.type}`));
+    if (deployment.spec.template && deployment.spec.template.spec.containers) {
+        console.log(chalk_1.default.bold('\nContainers:'));
+        deployment.spec.template.spec.containers.forEach((container) => {
+            console.log(chalk_1.default.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_1.default.bold('\nConditions:'));
+        console.log(chalk_1.default.bold('  Type           Status  Reason'));
+        deployment.status.conditions.forEach((condition) => {
+            console.log(`  ${condition.type.padEnd(15)}${condition.status.padEnd(8)}${condition.reason || ''}`);
+        });
+    }
+    console.log(chalk_1.default.bold('\nEvents:'));
+    console.log('  <Events not available in this implementation>');
+}
+exports.default = async (argv, prompter, _options) => {
+    try {
+        const client = new kubernetesjs_1.KubernetesClient({
+            restEndpoint: 'http://localhost:8001' // Default kube-proxy endpoint
+        });
+        const namespace = argv.n || argv.namespace || (0, config_1.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_1.default.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_1.default.yellow(`Resource type '${resourceType}' not implemented yet`));
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`Error: ${error}`));
+    }
+};