feat: implement kubectl-like commands for kubernetesjs CLI

Author: pyramation

packages/cli/package.json

@@ -34,6 +34,9 @@
     "test:watch": "jest --watch",
     "dev": "ts-node src/index.ts"
   },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.9"
+  },
   "dependencies": {
     "chalk": "^4.1.0",
     "deepmerge": "^4.3.1",

packages/cli/src/commands.ts

@@ -6,18 +6,46 @@ 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: Record<string, Function> = {
-  deploy
+  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: Partial<ParsedArgs>, prompter: Inquirerer, options: CLIOptions) => {
   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

packages/cli/src/commands/apply.ts

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

packages/cli/src/commands/cluster-info.ts

@@ -0,0 +1,34 @@
+import { CLIOptions, Inquirerer } from 'inquirerer';
+import { ParsedArgs } from 'minimist';
+import chalk from 'chalk';
+import { KubernetesClient } from 'kubernetesjs';
+
+export default async (
+  _argv: Partial<ParsedArgs>,
+  _prompter: Inquirerer,
+  _options: CLIOptions
+) => {
+  try {
+    const client = new KubernetesClient({
+      restEndpoint: 'http://localhost:8001' // Default kube-proxy endpoint
+    });
+
+    console.log(chalk.blue('Kubernetes cluster info:'));
+    
+    const apiVersions = await client.getAPIVersions({
+      params: {
+        
+      },
+      query: {
+        
+      }
+    });
+    console.log(chalk.bold('\nAPI Versions:'));
+    if (apiVersions.apiVersion) {
+      console.log(apiVersions.apiVersion)
+    }
+    
+  } catch (error) {
+    console.error(chalk.red(`Error: ${error}`));
+  }
+};

packages/cli/src/commands/config-handler.ts

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

packages/cli/src/commands/config.ts

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