@kubernetesjs/cli 0.0.3 → 0.1.0

package/commands/exec.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/exec.js

@@ -0,0 +1,145 @@
+"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");
+const child_process_1 = require("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_1.default.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_1.default.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_1.default.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_1.default.red(`Error getting containers: ${error}`));
+        return '';
+    }
+}
+async function execInPod(namespace, podName, containerName, command) {
+    console.log(chalk_1.default.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 = (0, child_process_1.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);
+        });
+    });
+}
+exports.default = async (argv, prompter, _options) => {
+    try {
+        const client = new kubernetesjs_1.KubernetesClient({
+            restEndpoint: argv.clientUrl
+        });
+        const namespace = argv.n || argv.namespace || (0, config_1.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_1.default.red(`Error: ${error}`));
+    }
+};

package/commands/get.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/get.js

@@ -0,0 +1,164 @@
+"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 = [
+        '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_1.default.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_1.default.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_1.default.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_1.default.bold('\nPODS:'));
+            console.log(chalk_1.default.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_1.default.bold('\nSERVICES:'));
+            console.log(chalk_1.default.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_1.default.bold('\nDEPLOYMENTS:'));
+            console.log(chalk_1.default.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_1.default.red(`Error getting resources: ${error}`));
+    }
+}
+exports.default = async (argv, prompter, _options) => {
+    try {
+        const client = new kubernetesjs_1.KubernetesClient({
+            restEndpoint: argv.clientUrl
+        });
+        const namespace = argv.n || argv.namespace || (0, config_1.getCurrentNamespace)();
+        const resourceType = argv._?.[0] || await promptResourceType(prompter, argv);
+        console.log(chalk_1.default.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_1.default.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_1.default.yellow('No pods found'));
+                }
+                break;
+            case 'services':
+                const services = await client.listCoreV1NamespacedService({
+                    path: { namespace },
+                    query: { limit: 100 }
+                });
+                console.log(chalk_1.default.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_1.default.yellow('No services found'));
+                }
+                break;
+            case 'deployments':
+                const deployments = await client.listAppsV1NamespacedDeployment({
+                    path: { namespace },
+                    query: { limit: 100 }
+                });
+                console.log(chalk_1.default.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_1.default.yellow('No deployments found'));
+                }
+                break;
+            default:
+                console.log(chalk_1.default.yellow(`Resource type '${resourceType}' not implemented yet`));
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`Error: ${error}`));
+    }
+};

package/commands/logs.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/logs.js

@@ -0,0 +1,110 @@
+"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 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_1.default.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_1.default.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_1.default.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_1.default.red(`Error getting containers: ${error}`));
+        return '';
+    }
+}
+exports.default = async (argv, prompter, _options) => {
+    try {
+        const client = new kubernetesjs_1.KubernetesClient({
+            restEndpoint: argv.clientUrl
+        });
+        const namespace = argv.n || argv.namespace || (0, config_1.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_1.default.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_1.default.red(`Error: ${error}`));
+    }
+};

package/commands/port-forward.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/port-forward.js

@@ -0,0 +1,143 @@
+"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");
+const child_process_1 = require("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_1.default.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_1.default.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_1.default.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_1.default.red(`Error getting service ports: ${error}`));
+        return '';
+    }
+}
+async function portForward(namespace, resourceType, resourceName, portMapping) {
+    console.log(chalk_1.default.blue(`Forwarding ports ${portMapping} to ${resourceType}/${resourceName} in namespace ${namespace}...`));
+    console.log(chalk_1.default.yellow('Press Ctrl+C to stop port forwarding'));
+    const kubectlArgs = [
+        'port-forward',
+        '-n', namespace,
+        `${resourceType}/${resourceName}`,
+        portMapping
+    ];
+    const kubectl = (0, child_process_1.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);
+        });
+    });
+}
+exports.default = async (argv, prompter, _options) => {
+    try {
+        const client = new kubernetesjs_1.KubernetesClient({
+            restEndpoint: argv.clientUrl
+        });
+        const namespace = argv.n || argv.namespace || (0, config_1.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_1.default.red(`Error: ${error}`));
+    }
+};

package/commands.d.ts

@@ -0,0 +1,3 @@
+import { CLIOptions, Inquirerer } from 'inquirerer';
+import { ParsedArgs } from 'minimist';
+export declare const commands: (argv: Partial<ParsedArgs>, prompter: Inquirerer, options: CLIOptions) => Promise<Partial<ParsedArgs>>;

package/commands.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commands = void 0;
+const package_1 = require("./package");
+const utils_1 = require("./utils");
+// Commands
+const deploy_1 = __importDefault(require("./commands/deploy"));
+const get_1 = __importDefault(require("./commands/get"));
+const describe_1 = __importDefault(require("./commands/describe"));
+const logs_1 = __importDefault(require("./commands/logs"));
+const apply_1 = __importDefault(require("./commands/apply"));
+const delete_1 = __importDefault(require("./commands/delete"));
+const exec_1 = __importDefault(require("./commands/exec"));
+const port_forward_1 = __importDefault(require("./commands/port-forward"));
+const cluster_info_1 = __importDefault(require("./commands/cluster-info"));
+const config_1 = __importDefault(require("./commands/config"));
+const commandMap = {
+    deploy: deploy_1.default,
+    get: get_1.default,
+    describe: describe_1.default,
+    logs: logs_1.default,
+    apply: apply_1.default,
+    delete: delete_1.default,
+    exec: exec_1.default,
+    'port-forward': port_forward_1.default,
+    'cluster-info': cluster_info_1.default,
+    config: config_1.default
+};
+const config_handler_1 = __importDefault(require("./commands/config-handler"));
+const commands = async (argv, prompter, options) => {
+    if (argv.version || argv.v) {
+        const pkg = (0, package_1.readAndParsePackageJson)();
+        console.log(pkg.version);
+        process.exit(0);
+    }
+    if (argv.config) {
+        const handled = await (0, config_handler_1.default)(argv, prompter, options, commandMap);
+        if (handled) {
+            prompter.close();
+            return argv;
+        }
+    }
+    let { first: command, newArgv } = (0, utils_1.extractFirst)(argv);
+    // Show usage if explicitly requested
+    if (argv.help || argv.h || command === 'help') {
+        console.log(utils_1.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(utils_1.usageText);
+        process.exit(1);
+    }
+    await commandFn(newArgv, prompter, options);
+    prompter.close();
+    return argv;
+};
+exports.commands = commands;