mcp-server-kubernetes 2.2.1 → 2.3.0

package/dist/tools/helm-operations.js

@@ -88,7 +88,8 @@ const executeHelmCommand = (command) => {
         // Add a generous timeout of 60 seconds for Helm operations
         return execSync(command, {
             encoding: "utf8",
-            timeout: 60000 // 60 seconds timeout
+            timeout: 60000, // 60 seconds timeout
+            env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG }
         });
     }
     catch (error) {

package/dist/tools/kubectl-apply.js

@@ -69,7 +69,7 @@ export async function kubectlApply(k8sManager, input) {
         }
         // Execute the command
         try {
-            const result = execSync(command, { encoding: "utf8" });
+            const result = execSync(command, { encoding: "utf8", env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG } });
             // Clean up temp file if created
             if (tempFile) {
                 try {

package/dist/tools/kubectl-context.js

@@ -52,7 +52,7 @@ export async function kubectlContext(k8sManager, input) {
                 }
                 else if (output === "custom" || output === "json") {
                     // For custom or JSON output, we'll format it ourselves
-                    const rawResult = execSync(command, { encoding: "utf8" });
+                    const rawResult = execSync(command, { encoding: "utf8", env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG } });
                     // Parse the tabular output from kubectl
                     const lines = rawResult.trim().split("\n");
                     const headers = lines[0].trim().split(/\s+/);
@@ -83,17 +83,17 @@ export async function kubectlContext(k8sManager, input) {
                     };
                 }
                 // Execute the command for non-json outputs
-                result = execSync(command, { encoding: "utf8" });
+                result = execSync(command, { encoding: "utf8", env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG } });
                 break;
             case "get":
                 // Build command to get current context
                 command = "kubectl config current-context";
                 // Execute the command
                 try {
-                    const currentContext = execSync(command, { encoding: "utf8" }).trim();
+                    const currentContext = execSync(command, { encoding: "utf8", env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG } }).trim();
                     if (detailed) {
                         // For detailed context info, we need to use get-contexts and filter
-                        const allContextsOutput = execSync("kubectl config get-contexts", { encoding: "utf8" });
+                        const allContextsOutput = execSync("kubectl config get-contexts", { encoding: "utf8", env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG } });
                         // Parse the tabular output from kubectl
                         const lines = allContextsOutput.trim().split("\n");
                         const headers = lines[0].trim().split(/\s+/);
@@ -169,7 +169,7 @@ export async function kubectlContext(k8sManager, input) {
                 }
                 // First check if the context exists
                 try {
-                    const allContextsOutput = execSync("kubectl config get-contexts -o name", { encoding: "utf8" });
+                    const allContextsOutput = execSync("kubectl config get-contexts -o name", { encoding: "utf8", env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG } });
                     const availableContexts = allContextsOutput.trim().split("\n");
                     // Extract the short name from the ARN if needed
                     let contextName = name;
@@ -186,7 +186,7 @@ export async function kubectlContext(k8sManager, input) {
                     // Build command to set context
                     command = `kubectl config use-context "${contextName}"`;
                     // Execute the command
-                    result = execSync(command, { encoding: "utf8" });
+                    result = execSync(command, { encoding: "utf8", env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG } });
                     // For tests to pass, we need to return the original name format that was passed in
                     return {
                         content: [

package/dist/tools/kubectl-create.js

@@ -280,7 +280,7 @@ export async function kubectlCreate(k8sManager, input) {
         command += ` -o ${output}`;
         // Execute the command
         try {
-            const result = execSync(command, { encoding: "utf8" });
+            const result = execSync(command, { encoding: "utf8", env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG } });
             // Clean up temp file if created
             if (tempFile) {
                 try {

package/dist/tools/kubectl-delete.js

@@ -109,7 +109,7 @@ export async function kubectlDelete(k8sManager, input) {
         }
         // Execute the command
         try {
-            const result = execSync(command, { encoding: "utf8" });
+            const result = execSync(command, { encoding: "utf8", env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG } });
             // Clean up temp file if created
             if (tempFile) {
                 try {

package/dist/tools/kubectl-describe.js

@@ -49,7 +49,7 @@ export async function kubectlDescribe(k8sManager, input) {
         }
         // Execute the command
         try {
-            const result = execSync(command, { encoding: "utf8" });
+            const result = execSync(command, { encoding: "utf8", env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG } });
             return {
                 content: [
                     {

package/dist/tools/kubectl-generic.js

@@ -98,7 +98,7 @@ export async function kubectlGeneric(k8sManager, input) {
         const command = cmdArgs.slice(1).join(' ');
         try {
             console.error(`Executing: kubectl ${command}`);
-            const result = execSync(`kubectl ${command}`, { encoding: "utf8" });
+            const result = execSync(`kubectl ${command}`, { encoding: "utf8", env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG } });
             return {
                 content: [
                     {

package/dist/tools/kubectl-get.js

@@ -115,7 +115,7 @@ export async function kubectlGet(k8sManager, input) {
         }
         // Execute the command
         try {
-            const result = execSync(command, { encoding: "utf8" });
+            const result = execSync(command, { encoding: "utf8", env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG } });
             // Format the results for better readability
             const isListOperation = !name;
             if (isListOperation && output === "json") {

package/dist/tools/kubectl-list.js

@@ -142,7 +142,7 @@ export async function kubectlList(k8sManager, input) {
         command += ` -o custom-columns="${customColumns}"`;
         // Execute the command
         try {
-            const result = execSync(command, { encoding: "utf8" });
+            const result = execSync(command, { encoding: "utf8", env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG } });
             return {
                 content: [
                     {

package/dist/tools/kubectl-logs.js

@@ -83,7 +83,7 @@ export async function kubectlLogs(k8sManager, input) {
             baseCommand = addLogOptions(baseCommand, input);
             // Execute the command
             try {
-                const result = execSync(baseCommand, { encoding: "utf8" });
+                const result = execSync(baseCommand, { encoding: "utf8", env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG } });
                 return formatLogOutput(name, result);
             }
             catch (error) {
@@ -104,7 +104,7 @@ export async function kubectlLogs(k8sManager, input) {
                 // For cronjobs, it's more complex - need to find the job first
                 const jobsCommand = `kubectl -n ${namespace} get jobs --selector=job-name=${name} -o jsonpath='{.items[*].metadata.name}'`;
                 try {
-                    const jobs = execSync(jobsCommand, { encoding: "utf8" }).trim().split(' ');
+                    const jobs = execSync(jobsCommand, { encoding: "utf8", env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG } }).trim().split(' ');
                     if (jobs.length === 0 || (jobs.length === 1 && jobs[0] === '')) {
                         return {
                             content: [
@@ -148,7 +148,7 @@ export async function kubectlLogs(k8sManager, input) {
                     if (!selectorCommand) {
                         throw new Error("Selector command is undefined");
                     }
-                    const selectorJson = execSync(selectorCommand, { encoding: "utf8" }).trim();
+                    const selectorJson = execSync(selectorCommand, { encoding: "utf8", env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG } }).trim();
                     const selector = JSON.parse(selectorJson.replace(/'/g, '"'));
                     // Convert to label selector format
                     const labelSelector = Object.entries(selector)
@@ -216,7 +216,7 @@ async function getLabelSelectorLogs(labelSelector, namespace, input) {
     try {
         // First, find all pods matching the label selector
         const podsCommand = `kubectl -n ${namespace} get pods --selector=${labelSelector} -o jsonpath='{.items[*].metadata.name}'`;
-        const pods = execSync(podsCommand, { encoding: "utf8" }).trim().split(' ');
+        const pods = execSync(podsCommand, { encoding: "utf8", env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG } }).trim().split(' ');
         if (pods.length === 0 || (pods.length === 1 && pods[0] === '')) {
             return {
                 content: [
@@ -243,7 +243,7 @@ async function getLabelSelectorLogs(labelSelector, namespace, input) {
             // Add other options
             podCommand = addLogOptions(podCommand, input);
             try {
-                const logs = execSync(podCommand, { encoding: "utf8" });
+                const logs = execSync(podCommand, { encoding: "utf8", env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG } });
                 logsMap[pod] = logs;
             }
             catch (error) {

package/dist/tools/kubectl-operations.js

@@ -60,7 +60,7 @@ export const listApiResourcesSchema = {
 };
 const executeKubectlCommand = (command) => {
     try {
-        return execSync(command, { encoding: "utf8" });
+        return execSync(command, { encoding: "utf8", env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG } });
     }
     catch (error) {
         throw new Error(`Kubectl command failed: ${error.message}`);

package/dist/tools/kubectl-patch.js

@@ -87,7 +87,7 @@ export async function kubectlPatch(k8sManager, input) {
         }
         // Execute the command
         try {
-            const result = execSync(command, { encoding: "utf8" });
+            const result = execSync(command, { encoding: "utf8", env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG } });
             // Clean up temp file if created
             if (tempFile) {
                 try {

package/dist/tools/kubectl-rollout.js

@@ -79,7 +79,8 @@ export async function kubectlRollout(k8sManager, input) {
                 // and capture the output until that point
                 const result = execSync(command, {
                     encoding: "utf8",
-                    timeout: 15000 // Reduced from 30 seconds to 15 seconds
+                    timeout: 15000, // Reduced from 30 seconds to 15 seconds
+                    env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG }
                 });
                 return {
                     content: [
@@ -91,7 +92,7 @@ export async function kubectlRollout(k8sManager, input) {
                 };
             }
             else {
-                const result = execSync(command, { encoding: "utf8" });
+                const result = execSync(command, { encoding: "utf8", env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG } });
                 return {
                     content: [
                         {

package/dist/tools/kubectl-scale.js

@@ -36,7 +36,7 @@ export async function kubectlScale(k8sManager, input) {
         let command = `kubectl scale ${resourceType} ${input.name} --replicas=${input.replicas} --namespace=${namespace}`;
         // Execute the command
         try {
-            const result = execSync(command, { encoding: "utf8" });
+            const result = execSync(command, { encoding: "utf8", env: { ...process.env, KUBECONFIG: process.env.KUBECONFIG } });
             return {
                 content: [
                     {

package/dist/utils/kubernetes-manager.d.ts

@@ -45,6 +45,7 @@ export declare class KubernetesManager {
      * Check if KUBECONFIG_PATH environment variable is available
      */
     private hasEnvKubeconfigPath;
+    private hasEnvKubeconfig;
     /**
      * Set the current context to the desired context name.
      *
@@ -67,4 +68,9 @@ export declare class KubernetesManager {
      * Uses K8S_NAMESPACE environment variable if set, otherwise defaults to "default"
      */
     getDefaultNamespace(): string;
+    /**
+     * Create temporary kubeconfig file from YAML content for kubectl commands
+     * @param kubeconfigYaml YAML content of the kubeconfig
+     */
+    private createTempKubeconfigFromYaml;
 }

package/dist/utils/kubernetes-manager.js

@@ -1,5 +1,7 @@
-import * as k8s from "@kubernetes/client-node";
 import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import * as k8s from "@kubernetes/client-node";
 export class KubernetesManager {
     resources = [];
     portForwards = [];
@@ -10,48 +12,61 @@ export class KubernetesManager {
     k8sBatchApi;
     constructor() {
         this.kc = new k8s.KubeConfig();
-        if (this.isRunningInCluster()) {
-            // Priority 1: In-cluster configuration (existing)
-            this.kc.loadFromCluster();
-        }
-        else if (this.hasEnvKubeconfigYaml()) {
-            // Priority 2: Full kubeconfig as YAML string
+        if (this.hasEnvKubeconfigYaml()) {
+            // Priority 1: Full kubeconfig as YAML string
             try {
                 this.loadEnvKubeconfigYaml();
+                this.createTempKubeconfigFromYaml(process.env.KUBECONFIG_YAML);
             }
             catch (error) {
-                throw new Error(`Failed to parse KUBECONFIG_YAML: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                throw new Error(`Failed to parse KUBECONFIG_YAML: ${error instanceof Error ? error.message : "Unknown error"}`);
             }
         }
+        else if (this.isRunningInCluster()) {
+            // Priority 2: Check if running in cluster
+            this.kc.loadFromCluster();
+        }
         else if (this.hasEnvKubeconfigJson()) {
             // Priority 3: Full kubeconfig as JSON string
             try {
                 this.loadEnvKubeconfigJson();
+                // Create temp kubeconfig file for kubectl commands from JSON
+                const yamlConfig = this.kc.exportConfig();
+                this.createTempKubeconfigFromYaml(yamlConfig);
             }
             catch (error) {
-                throw new Error(`Failed to parse KUBECONFIG_JSON: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                throw new Error(`Failed to parse KUBECONFIG_JSON: ${error instanceof Error ? error.message : "Unknown error"}`);
             }
         }
         else if (this.hasEnvMinimalKubeconfig()) {
             // Priority 4: Minimal config with individual environment variables
             try {
                 this.loadEnvMinimalKubeconfig();
+                // Create temp kubeconfig file for kubectl commands from minimal config
+                const yamlConfig = this.kc.exportConfig();
+                this.createTempKubeconfigFromYaml(yamlConfig);
             }
             catch (error) {
-                throw new Error(`Failed to create kubeconfig from K8S_SERVER and K8S_TOKEN: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                throw new Error(`Failed to create kubeconfig from K8S_SERVER and K8S_TOKEN: ${error instanceof Error ? error.message : "Unknown error"}`);
             }
         }
         else if (this.hasEnvKubeconfigPath()) {
-            // Priority 5: Custom kubeconfig file path
+            // Priority 5: Custom kubeconfig file path using KUBECONFIG_PATH
             try {
                 this.loadEnvKubeconfigPath();
+                // Set KUBECONFIG environment variable to the custom path for kubectl commands
+                process.env.KUBECONFIG = process.env.KUBECONFIG_PATH;
             }
             catch (error) {
-                throw new Error(`Failed to load kubeconfig from KUBECONFIG_PATH: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                throw new Error(`Failed to load kubeconfig from KUBECONFIG_PATH: ${error instanceof Error ? error.message : "Unknown error"}`);
             }
         }
+        else if (this.hasEnvKubeconfig()) {
+            // Load from KUBECONFIG
+            this.kc.loadFromFile(process.env.KUBECONFIG);
+        }
         else {
-            // Priority 6: Default file-based configuration (existing fallback)
+            // Priority 7: Default file-based configuration (existing fallback)
             this.kc.loadFromDefault();
         }
         // Apply context override if specified
@@ -60,7 +75,7 @@ export class KubernetesManager {
                 this.setCurrentContext(process.env.K8S_CONTEXT);
             }
             catch (error) {
-                console.warn(`Warning: Could not set context to ${process.env.K8S_CONTEXT}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                console.warn(`Warning: Could not set context to ${process.env.K8S_CONTEXT}: ${error instanceof Error ? error.message : "Unknown error"}`);
             }
         }
         // Initialize API clients
@@ -111,6 +126,10 @@ export class KubernetesManager {
      * Load kubeconfig from KUBECONFIG_YAML environment variable (YAML format)
      */
     loadEnvKubeconfigYaml() {
+        if (!process.env.KUBECONFIG_YAML) {
+            throw new Error("KUBECONFIG_YAML environment variable is not set");
+        }
+        // Load the config into the JavaScript client
         this.kc.loadFromString(process.env.KUBECONFIG_YAML);
     }
     /**
@@ -125,28 +144,29 @@ export class KubernetesManager {
      */
     loadEnvMinimalKubeconfig() {
         if (!process.env.K8S_SERVER || !process.env.K8S_TOKEN) {
-            throw new Error('K8S_SERVER and K8S_TOKEN environment variables are required');
+            throw new Error("K8S_SERVER and K8S_TOKEN environment variables are required");
         }
         const cluster = {
-            name: 'env-cluster',
+            name: "env-cluster",
             server: process.env.K8S_SERVER,
-            skipTLSVerify: process.env.K8S_SKIP_TLS_VERIFY === 'true'
+            skipTLSVerify: process.env.K8S_SKIP_TLS_VERIFY === "true",
         };
         const user = {
-            name: 'env-user',
-            token: process.env.K8S_TOKEN
+            name: "env-user",
+            token: process.env.K8S_TOKEN,
         };
         const context = {
-            name: 'env-context',
+            name: "env-context",
             user: user.name,
-            cluster: cluster.name
+            cluster: cluster.name,
         };
-        this.kc.loadFromOptions({
+        const kubeconfigContent = {
             clusters: [cluster],
             users: [user],
             contexts: [context],
-            currentContext: context.name
-        });
+            currentContext: context.name,
+        };
+        this.kc.loadFromOptions(kubeconfigContent);
     }
     /**
      * Check if KUBECONFIG_PATH environment variable is available
@@ -154,6 +174,9 @@ export class KubernetesManager {
     hasEnvKubeconfigPath() {
         return !!(process.env.KUBECONFIG_PATH && process.env.KUBECONFIG_PATH.trim());
     }
+    hasEnvKubeconfig() {
+        return !!(process.env.KUBECONFIG && process.env.KUBECONFIG.trim());
+    }
     /**
      * Set the current context to the desired context name.
      *
@@ -184,7 +207,7 @@ export class KubernetesManager {
                 await this.deleteResource(resource.kind, resource.name, resource.namespace);
             }
             catch (error) {
-                console.error(`Failed to delete ${resource.kind} ${resource.name}:`, error);
+                process.stderr.write(`Failed to delete ${resource.kind} ${resource.name}: ${error}\n`);
             }
         }
     }
@@ -237,6 +260,56 @@ export class KubernetesManager {
      * Uses K8S_NAMESPACE environment variable if set, otherwise defaults to "default"
      */
     getDefaultNamespace() {
-        return process.env.K8S_NAMESPACE || 'default';
+        return process.env.K8S_NAMESPACE || "default";
+    }
+    /**
+     * Create temporary kubeconfig file from YAML content for kubectl commands
+     * @param kubeconfigYaml YAML content of the kubeconfig
+     */
+    createTempKubeconfigFromYaml(kubeconfigYaml) {
+        try {
+            if (!kubeconfigYaml || typeof kubeconfigYaml !== "string") {
+                throw new Error(`Invalid kubeconfigYaml: ${typeof kubeconfigYaml}`);
+            }
+            const tempDir = os.tmpdir();
+            const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+            const randomString = Math.random().toString(36).substring(2);
+            const tempKubeconfigPath = path.join(tempDir, `kubeconfig-${timestamp}-${randomString}`);
+            // Write temporary kubeconfig file
+            fs.writeFileSync(tempKubeconfigPath, kubeconfigYaml, {
+                mode: 0o600,
+                encoding: "utf8",
+            });
+            // Set KUBECONFIG environment variable for kubectl commands
+            process.env.KUBECONFIG = tempKubeconfigPath;
+            // Function to clean up the temporary file
+            const cleanupTempFile = () => {
+                try {
+                    if (fs.existsSync(tempKubeconfigPath)) {
+                        fs.unlinkSync(tempKubeconfigPath);
+                    }
+                }
+                catch (cleanupError) {
+                    // Ignore cleanup errors
+                }
+            };
+            // Schedule cleanup of temporary file when process exits
+            process.on("exit", cleanupTempFile);
+            // Also clean up on SIGINT and SIGTERM (common in Docker containers)
+            ["SIGINT", "SIGTERM"].forEach((signal) => {
+                process.on(signal, () => {
+                    cleanupTempFile();
+                    process.exit(0);
+                });
+            });
+            // Additional cleanup for Docker container lifecycle
+            ["SIGUSR1", "SIGUSR2"].forEach((signal) => {
+                process.on(signal, cleanupTempFile);
+            });
+        }
+        catch (error) {
+            // Continue without temporary file - kubectl commands may fail but JavaScript client will work
+            throw error;
+        }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-server-kubernetes",
-  "version": "2.2.1",
+  "version": "2.3.0",
   "description": "MCP server for interacting with Kubernetes clusters via kubectl",
   "license": "MIT",
   "type": "module",