mcp-server-kubernetes 2.2.1 → 2.3.1

package/dist/config/container-templates.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import * as k8s from "@kubernetes/client-node";
+import type { V1Container } from "@kubernetes/client-node";
 export declare const ContainerTemplate: z.ZodEnum<["ubuntu", "nginx", "busybox", "alpine", "custom"]>;
 export type ContainerTemplateName = z.infer<typeof ContainerTemplate>;
 export declare const CustomContainerConfig: z.ZodObject<{
@@ -103,4 +103,4 @@ export declare const CustomContainerConfig: z.ZodObject<{
     }[] | undefined;
 }>;
 export type CustomContainerConfigType = z.infer<typeof CustomContainerConfig>;
-export declare const containerTemplates: Record<string, k8s.V1Container>;
+export declare const containerTemplates: Record<string, V1Container>;

package/dist/index.js

@@ -11,22 +11,22 @@ import { cleanupSchema } from "./config/cleanup-config.js";
 import { startSSEServer } from "./utils/sse.js";
 import { startPortForward, PortForwardSchema, stopPortForward, StopPortForwardSchema, } from "./tools/port_forward.js";
 import { kubectlScale, kubectlScaleSchema } from "./tools/kubectl-scale.js";
-import { kubectlContext, kubectlContextSchema } from "./tools/kubectl-context.js";
+import { kubectlContext, kubectlContextSchema, } from "./tools/kubectl-context.js";
 import { kubectlGet, kubectlGetSchema } from "./tools/kubectl-get.js";
-import { kubectlDescribe, kubectlDescribeSchema } from "./tools/kubectl-describe.js";
+import { kubectlDescribe, kubectlDescribeSchema, } from "./tools/kubectl-describe.js";
 import { kubectlList, kubectlListSchema } from "./tools/kubectl-list.js";
 import { kubectlApply, kubectlApplySchema } from "./tools/kubectl-apply.js";
 import { kubectlDelete, kubectlDeleteSchema } from "./tools/kubectl-delete.js";
 import { kubectlCreate, kubectlCreateSchema } from "./tools/kubectl-create.js";
 import { kubectlLogs, kubectlLogsSchema } from "./tools/kubectl-logs.js";
-import { kubectlGeneric, kubectlGenericSchema } from "./tools/kubectl-generic.js";
+import { kubectlGeneric, kubectlGenericSchema, } from "./tools/kubectl-generic.js";
 import { kubectlPatch, kubectlPatchSchema } from "./tools/kubectl-patch.js";
-import { kubectlRollout, kubectlRolloutSchema } from "./tools/kubectl-rollout.js";
+import { kubectlRollout, kubectlRolloutSchema, } from "./tools/kubectl-rollout.js";
 // Check if non-destructive tools only mode is enabled
 const nonDestructiveTools = process.env.ALLOW_ONLY_NON_DESTRUCTIVE_TOOLS === "true";
 // Define destructive tools (delete and uninstall operations)
 const destructiveTools = [
-    kubectlDeleteSchema, // This replaces all individual delete operations 
+    kubectlDeleteSchema, // This replaces all individual delete operations
     uninstallHelmChartSchema,
     cleanupSchema, // Cleanup is also destructive as it deletes resources
     kubectlGenericSchema, // Generic kubectl command can perform destructive operations
@@ -123,7 +123,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 fieldSelector: input.fieldSelector,
                 labelSelector: input.labelSelector,
                 sortBy: input.sortBy,
-                output: input.output
+                output: input.output,
             });
         }
         // Handle specific non-kubectl operations

package/dist/resources/handlers.js

@@ -44,13 +44,13 @@ export const getResourceHandlers = (k8sManager) => ({
             const isNodes = parts[0] === "nodes";
             if ((isNamespaces || isNodes) && parts.length === 1) {
                 const fn = isNodes ? "listNode" : "listNamespace";
-                const { body } = await k8sManager.getCoreApi()[fn]();
+                const { items } = await k8sManager.getCoreApi()[fn]();
                 return {
                     contents: [
                         {
                             uri: request.params.uri,
                             mimeType: "application/json",
-                            text: JSON.stringify(body.items, null, 2),
+                            text: JSON.stringify(items, null, 2),
                         },
                     ],
                 };
@@ -58,43 +58,43 @@ export const getResourceHandlers = (k8sManager) => ({
             const [namespace, resourceType] = parts;
             switch (resourceType) {
                 case "pods": {
-                    const { body } = await k8sManager
+                    const { items } = await k8sManager
                         .getCoreApi()
-                        .listNamespacedPod(namespace);
+                        .listNamespacedPod({ namespace });
                     return {
                         contents: [
                             {
                                 uri: request.params.uri,
                                 mimeType: "application/json",
-                                text: JSON.stringify(body.items, null, 2),
+                                text: JSON.stringify(items, null, 2),
                             },
                         ],
                     };
                 }
                 case "deployments": {
-                    const { body } = await k8sManager
+                    const { items } = await k8sManager
                         .getAppsApi()
-                        .listNamespacedDeployment(namespace);
+                        .listNamespacedDeployment({ namespace });
                     return {
                         contents: [
                             {
                                 uri: request.params.uri,
                                 mimeType: "application/json",
-                                text: JSON.stringify(body.items, null, 2),
+                                text: JSON.stringify(items, null, 2),
                             },
                         ],
                     };
                 }
                 case "services": {
-                    const { body } = await k8sManager
+                    const { items } = await k8sManager
                         .getCoreApi()
-                        .listNamespacedService(namespace);
+                        .listNamespacedService({ namespace });
                     return {
                         contents: [
                             {
                                 uri: request.params.uri,
                                 mimeType: "application/json",
-                                text: JSON.stringify(body.items, null, 2),
+                                text: JSON.stringify(items, null, 2),
                             },
                         ],
                     };

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

@@ -8,43 +8,43 @@ export const kubectlGetSchema = {
         properties: {
             resourceType: {
                 type: "string",
-                description: "Type of resource to get (e.g., pods, deployments, services, configmaps, events, etc.)"
+                description: "Type of resource to get (e.g., pods, deployments, services, configmaps, events, etc.)",
             },
             name: {
                 type: "string",
-                description: "Name of the resource (optional - if not provided, lists all resources of the specified type)"
+                description: "Name of the resource (optional - if not provided, lists all resources of the specified type)",
             },
             namespace: {
                 type: "string",
                 description: "Namespace of the resource (optional - defaults to 'default' for namespaced resources)",
-                default: "default"
+                default: "default",
             },
             output: {
                 type: "string",
                 enum: ["json", "yaml", "wide", "name", "custom"],
                 description: "Output format",
-                default: "json"
+                default: "json",
             },
             allNamespaces: {
                 type: "boolean",
                 description: "If true, list resources across all namespaces",
-                default: false
+                default: false,
             },
             labelSelector: {
                 type: "string",
                 description: "Filter resources by label selector (e.g. 'app=nginx')",
-                optional: true
+                optional: true,
             },
             fieldSelector: {
                 type: "string",
                 description: "Filter resources by field selector (e.g. 'metadata.name=my-pod')",
-                optional: true
+                optional: true,
             },
             sortBy: {
                 type: "string",
                 description: "Sort events by a field (default: lastTimestamp). Only applicable for events.",
-                optional: true
-            }
+                optional: true,
+            },
         },
         required: ["resourceType"],
     },
@@ -68,8 +68,11 @@ export async function kubectlGet(k8sManager, input) {
             command += ` ${name}`;
         }
         // For events, default to all namespaces unless explicitly specified
-        const shouldShowAllNamespaces = resourceType === "events" ?
-            (input.namespace ? false : true) : allNamespaces;
+        const shouldShowAllNamespaces = resourceType === "events"
+            ? input.namespace
+                ? false
+                : true
+            : allNamespaces;
         // Add namespace flag unless all namespaces is specified
         if (shouldShowAllNamespaces) {
             command += " --all-namespaces";
@@ -115,7 +118,10 @@ 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") {
@@ -152,7 +158,7 @@ export async function kubectlGet(k8sManager, input) {
                                 namespace: item.metadata?.namespace || "",
                                 kind: item.kind || resourceType,
                                 status: getResourceStatus(item),
-                                createdAt: item.metadata?.creationTimestamp
+                                createdAt: item.metadata?.creationTimestamp,
                             }));
                             return {
                                 content: [
@@ -239,13 +245,21 @@ function getResourceStatus(resource) {
 // Helper function to determine if a resource is non-namespaced
 function isNonNamespacedResource(resourceType) {
     const nonNamespacedResources = [
-        "nodes", "node", "no",
-        "namespaces", "namespace", "ns",
-        "persistentvolumes", "pv",
-        "storageclasses", "sc",
+        "nodes",
+        "node",
+        "no",
+        "namespaces",
+        "namespace",
+        "ns",
+        "persistentvolumes",
+        "pv",
+        "storageclasses",
+        "sc",
         "clusterroles",
         "clusterrolebindings",
-        "customresourcedefinitions", "crd", "crds"
+        "customresourcedefinitions",
+        "crd",
+        "crds",
     ];
     return nonNamespacedResources.includes(resourceType.toLowerCase());
 }

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`);
             }
         }
     }
@@ -194,16 +217,16 @@ export class KubernetesManager {
     async deleteResource(kind, name, namespace) {
         switch (kind.toLowerCase()) {
             case "pod":
-                await this.k8sApi.deleteNamespacedPod(name, namespace);
+                await this.k8sApi.deleteNamespacedPod({ name, namespace });
                 break;
             case "deployment":
-                await this.k8sAppsApi.deleteNamespacedDeployment(name, namespace);
+                await this.k8sAppsApi.deleteNamespacedDeployment({ name, namespace });
                 break;
             case "service":
-                await this.k8sApi.deleteNamespacedService(name, namespace);
+                await this.k8sApi.deleteNamespacedService({ name, namespace });
                 break;
             case "cronjob":
-                await this.k8sBatchApi.deleteNamespacedCronJob(name, namespace);
+                await this.k8sBatchApi.deleteNamespacedCronJob({ name, namespace });
                 break;
         }
         this.resources = this.resources.filter((r) => !(r.kind === kind && r.name === name && r.namespace === namespace));
@@ -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.1",
   "description": "MCP server for interacting with Kubernetes clusters via kubectl",
   "license": "MIT",
   "type": "module",
@@ -35,7 +35,7 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@kubernetes/client-node": "0.20.0",
+    "@kubernetes/client-node": "1.3.0",
     "@modelcontextprotocol/sdk": "1.7.0",
     "express": "4.21.2",
     "js-yaml": "4.1.0",
@@ -49,10 +49,5 @@
     "shx": "0.3.4",
     "typescript": "5.6.2",
     "vitest": "2.1.9"
-  },
-  "overrides": {
-    "@kubernetes/client-node": {
-      "jsonpath-plus": "^10.3.0"
-    }
   }
 }