mcp-server-kubernetes 1.0.1 → 1.1.0

package/README.md

@@ -66,16 +66,10 @@ npx mcp-chat --config "%APPDATA%\Claude\claude_desktop_config.json"
 ## Features
 
 - [x] Connect to a Kubernetes cluster
-- [x] List all pods
-- [x] List all services
-- [x] List all deployments
-- [x] List all nodes
-- [x] Create a pod
-- [x] Delete a pod
-- [x] Describe a pod
-- [x] List all namespaces
-- [x] Create a namespace
-- [x] Create custom pod & deployment configs
+- [x] List all pods, services, deployments, nodes
+- [x] Create, describe, delete a pod
+- [x] List all namespaces, create a namespace
+- [x] Create custom pod & deployment configs, update deployment replicas
 - [x] Get logs from a pod for debugging (supports pods, deployments, jobs, and label selectors)
 - [x] Support Helm v3 for installing charts
   - Install charts with custom values
@@ -87,6 +81,7 @@ npx mcp-chat --config "%APPDATA%\Claude\claude_desktop_config.json"
 - [x] kubectl explain and kubectl api-resources support
 - [x] Get Kubernetes events from the cluster
 - [x] Port forward to a pod or service
+- [x] Create, list, and decribe cronjobs
 
 ## Local Development
 

package/dist/index.js

@@ -5,10 +5,15 @@ import { listPods, listPodsSchema } from "./tools/list_pods.js";
 import { listNodes, listNodesSchema } from "./tools/list_nodes.js";
 import { listServices, listServicesSchema } from "./tools/list_services.js";
 import { listDeployments, listDeploymentsSchema, } from "./tools/list_deployments.js";
+import { listCronJobs, listCronJobsSchema } from "./tools/list_cronjobs.js";
+import { describeCronJob, describeCronJobSchema } from "./tools/describe_cronjob.js";
+import { listJobs, listJobsSchema } from "./tools/list_jobs.js";
+import { getJobLogs, getJobLogsSchema } from "./tools/get_job_logs.js";
 import { installHelmChart, installHelmChartSchema, upgradeHelmChart, upgradeHelmChartSchema, uninstallHelmChart, uninstallHelmChartSchema, } from "./tools/helm-operations.js";
 import { explainResource, explainResourceSchema, listApiResources, listApiResourcesSchema, } from "./tools/kubectl-operations.js";
 import { createNamespace, createNamespaceSchema, } from "./tools/create_namespace.js";
 import { createPod, createPodSchema } from "./tools/create_pod.js";
+import { createCronJob, createCronJobSchema } from "./tools/create_cronjob.js";
 import { deletePod, deletePodSchema } from "./tools/delete_pod.js";
 import { describePod, describePodSchema } from "./tools/describe_pod.js";
 import { getLogs, getLogsSchema } from "./tools/get_logs.js";
@@ -24,6 +29,7 @@ import { startSSEServer } from "./utils/sse.js";
 import { startPortForward, PortForwardSchema, stopPortForward, StopPortForwardSchema, } from "./tools/port_forward.js";
 import { deleteDeployment } from "./tools/delete_deployment.js";
 import { createDeployment } from "./tools/create_deployment.js";
+import { scaleDeployment, scaleDeploymentSchema } from "./tools/scale_deployment.js";
 import { describeDeployment, describeDeploymentSchema, } from "./tools/describe_deployment.js";
 const k8sManager = new KubernetesManager();
 const server = new Server({
@@ -38,15 +44,20 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             createDeploymentSchema,
             createNamespaceSchema,
             createPodSchema,
+            createCronJobSchema,
             deletePodSchema,
+            describeCronJobSchema,
             describePodSchema,
             describeDeploymentSchema,
             explainResourceSchema,
             getEventsSchema,
+            getJobLogsSchema,
             getLogsSchema,
             installHelmChartSchema,
             listApiResourcesSchema,
+            listCronJobsSchema,
             listDeploymentsSchema,
+            listJobsSchema,
             listNamespacesSchema,
             listNodesSchema,
             listPodsSchema,
@@ -55,6 +66,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             upgradeHelmChartSchema,
             PortForwardSchema,
             StopPortForwardSchema,
+            scaleDeploymentSchema,
         ],
     };
 });
@@ -81,6 +93,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "create_pod": {
                 return await createPod(k8sManager, input);
             }
+            case "create_cronjob": {
+                return await createCronJob(k8sManager, input);
+            }
             case "delete_pod": {
                 return await deletePod(k8sManager, input);
             }
@@ -130,6 +145,18 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "list_services": {
                 return await listServices(k8sManager, input);
             }
+            case "list_cronjobs": {
+                return await listCronJobs(k8sManager, input);
+            }
+            case "describe_cronjob": {
+                return await describeCronJob(k8sManager, input);
+            }
+            case "list_jobs": {
+                return await listJobs(k8sManager, input);
+            }
+            case "get_job_logs": {
+                return await getJobLogs(k8sManager, input);
+            }
             case "uninstall_helm_chart": {
                 return await uninstallHelmChart(input);
             }
@@ -151,6 +178,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "describe_deployment": {
                 return await describeDeployment(k8sManager, input);
             }
+            case "scale_deployment": {
+                return await scaleDeployment(k8sManager, input);
+            }
             default:
                 throw new McpError(ErrorCode.InvalidRequest, `Unknown tool: ${name}`);
         }

package/dist/models/response-schemas.d.ts

@@ -285,6 +285,116 @@ export declare const GetEventsResponseSchema: z.ZodObject<{
         text: string;
     }[];
 }>;
+export declare const ListCronJobsResponseSchema: z.ZodObject<{
+    content: z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "text";
+        text: string;
+    }, {
+        type: "text";
+        text: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare const CreateCronJobResponseSchema: z.ZodObject<{
+    content: z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "text";
+        text: string;
+    }, {
+        type: "text";
+        text: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare const DescribeCronJobResponseSchema: z.ZodObject<{
+    content: z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "text";
+        text: string;
+    }, {
+        type: "text";
+        text: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare const ListJobsResponseSchema: z.ZodObject<{
+    content: z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "text";
+        text: string;
+    }, {
+        type: "text";
+        text: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare const GetJobLogsResponseSchema: z.ZodObject<{
+    content: z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "text";
+        text: string;
+    }, {
+        type: "text";
+        text: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}, {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
 export declare const PortForwardResponseSchema: z.ZodObject<{
     content: z.ZodArray<z.ZodObject<{
         success: z.ZodBoolean;
@@ -307,3 +417,25 @@ export declare const PortForwardResponseSchema: z.ZodObject<{
         success: boolean;
     }[];
 }>;
+export declare const ScaleDeploymentResponseSchema: z.ZodObject<{
+    content: z.ZodArray<z.ZodObject<{
+        success: z.ZodBoolean;
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        success: boolean;
+    }, {
+        message: string;
+        success: boolean;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    content: {
+        message: string;
+        success: boolean;
+    }[];
+}, {
+    content: {
+        message: string;
+        success: boolean;
+    }[];
+}>;

package/dist/models/response-schemas.js

@@ -43,9 +43,30 @@ export const GetLogsResponseSchema = z.object({
 export const GetEventsResponseSchema = z.object({
     content: z.array(ToolResponseContent),
 });
+export const ListCronJobsResponseSchema = z.object({
+    content: z.array(ToolResponseContent),
+});
+export const CreateCronJobResponseSchema = z.object({
+    content: z.array(ToolResponseContent),
+});
+export const DescribeCronJobResponseSchema = z.object({
+    content: z.array(ToolResponseContent),
+});
+export const ListJobsResponseSchema = z.object({
+    content: z.array(ToolResponseContent),
+});
+export const GetJobLogsResponseSchema = z.object({
+    content: z.array(ToolResponseContent),
+});
 export const PortForwardResponseSchema = z.object({
     content: z.array(z.object({
         success: z.boolean(),
         message: z.string(),
     })),
 });
+export const ScaleDeploymentResponseSchema = z.object({
+    content: z.array(z.object({
+        success: z.boolean(),
+        message: z.string(),
+    })),
+});

package/dist/tools/create_cronjob.d.ts

@@ -0,0 +1,47 @@
+import { KubernetesManager } from "../types.js";
+export declare const createCronJobSchema: {
+    readonly name: "create_cronjob";
+    readonly description: "Create a new Kubernetes CronJob";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly name: {
+                readonly type: "string";
+            };
+            readonly namespace: {
+                readonly type: "string";
+            };
+            readonly schedule: {
+                readonly type: "string";
+            };
+            readonly image: {
+                readonly type: "string";
+            };
+            readonly command: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+                readonly optional: true;
+            };
+            readonly suspend: {
+                readonly type: "boolean";
+                readonly optional: true;
+            };
+        };
+        readonly required: readonly ["name", "namespace", "schedule", "image"];
+    };
+};
+export declare function createCronJob(k8sManager: KubernetesManager, input: {
+    name: string;
+    namespace: string;
+    schedule: string;
+    image: string;
+    command?: string[];
+    suspend?: boolean;
+}): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/tools/create_cronjob.js

@@ -0,0 +1,93 @@
+export const createCronJobSchema = {
+    name: "create_cronjob",
+    description: "Create a new Kubernetes CronJob",
+    inputSchema: {
+        type: "object",
+        properties: {
+            name: { type: "string" },
+            namespace: { type: "string" },
+            schedule: { type: "string" },
+            image: { type: "string" },
+            command: {
+                type: "array",
+                items: { type: "string" },
+                optional: true,
+            },
+            suspend: {
+                type: "boolean",
+                optional: true,
+            },
+        },
+        required: ["name", "namespace", "schedule", "image"],
+    },
+};
+export async function createCronJob(k8sManager, input) {
+    try {
+        const cronJob = {
+            apiVersion: "batch/v1",
+            kind: "CronJob",
+            metadata: {
+                name: input.name,
+                namespace: input.namespace,
+                labels: {
+                    "mcp-managed": "true",
+                    app: input.name,
+                },
+            },
+            spec: {
+                schedule: input.schedule,
+                suspend: input.suspend || false,
+                jobTemplate: {
+                    spec: {
+                        template: {
+                            spec: {
+                                containers: [
+                                    {
+                                        name: input.name,
+                                        image: input.image,
+                                        ...(input.command && {
+                                            command: input.command,
+                                        }),
+                                    },
+                                ],
+                                restartPolicy: "OnFailure",
+                            },
+                        },
+                    },
+                },
+            },
+        };
+        const response = await k8sManager
+            .getBatchApi()
+            .createNamespacedCronJob(input.namespace, cronJob)
+            .catch((error) => {
+            console.error("CronJob creation error:", {
+                status: error.response?.statusCode,
+                message: error.response?.body?.message || error.message,
+                details: error.response?.body,
+            });
+            throw error;
+        });
+        k8sManager.trackResource("CronJob", input.name, input.namespace);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        cronJobName: response.body.metadata.name,
+                        schedule: response.body.spec.schedule,
+                        status: "created",
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        console.error("CronJob creation error:", {
+            status: error.response?.statusCode,
+            message: error.response?.body?.message || error.message,
+            details: error.response?.body,
+        });
+        throw error;
+    }
+}

package/dist/tools/describe_cronjob.d.ts

@@ -0,0 +1,27 @@
+import { KubernetesManager } from "../types.js";
+export declare const describeCronJobSchema: {
+    readonly name: "describe_cronjob";
+    readonly description: "Get detailed information about a Kubernetes CronJob including recent job history";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly name: {
+                readonly type: "string";
+            };
+            readonly namespace: {
+                readonly type: "string";
+                readonly default: "default";
+            };
+        };
+        readonly required: readonly ["name", "namespace"];
+    };
+};
+export declare function describeCronJob(k8sManager: KubernetesManager, input: {
+    name: string;
+    namespace: string;
+}): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/tools/describe_cronjob.js

@@ -0,0 +1,83 @@
+export const describeCronJobSchema = {
+    name: "describe_cronjob",
+    description: "Get detailed information about a Kubernetes CronJob including recent job history",
+    inputSchema: {
+        type: "object",
+        properties: {
+            name: { type: "string" },
+            namespace: { type: "string", default: "default" },
+        },
+        required: ["name", "namespace"],
+    },
+};
+export async function describeCronJob(k8sManager, input) {
+    try {
+        // Get the CronJob details
+        const batchV1Api = k8sManager.getBatchApi();
+        const cronJobResponse = await batchV1Api.readNamespacedCronJob(input.name, input.namespace);
+        const cronJob = cronJobResponse.body;
+        // Get recent Jobs associated with this CronJob
+        const labelSelector = `app=${input.name},cronjob-name=${input.name}`;
+        const jobsResponse = await batchV1Api.listNamespacedJob(input.namespace, undefined, // pretty
+        undefined, // allowWatchBookmarks
+        undefined, // _continue
+        undefined, // fieldSelector
+        labelSelector);
+        // Sort jobs by creation time (newest first)
+        const jobs = jobsResponse.body.items.sort((a, b) => {
+            const aTime = a.metadata?.creationTimestamp
+                ? new Date(a.metadata.creationTimestamp)
+                : new Date(0);
+            const bTime = b.metadata?.creationTimestamp
+                ? new Date(b.metadata.creationTimestamp)
+                : new Date(0);
+            return bTime.getTime() - aTime.getTime();
+        });
+        // Limit to 5 most recent jobs
+        const recentJobs = jobs.slice(0, 5).map((job) => ({
+            name: job.metadata?.name || "",
+            creationTime: job.metadata?.creationTimestamp || "",
+            status: {
+                active: job.status?.active || 0,
+                succeeded: job.status?.succeeded || 0,
+                failed: job.status?.failed || 0,
+                completionTime: job.status?.completionTime || null,
+            },
+        }));
+        // Format the response with CronJob details and recent jobs
+        const cronJobDetails = {
+            name: cronJob.metadata?.name || "",
+            namespace: cronJob.metadata?.namespace || "",
+            schedule: cronJob.spec?.schedule || "",
+            suspend: cronJob.spec?.suspend || false,
+            concurrencyPolicy: cronJob.spec?.concurrencyPolicy || "Allow",
+            lastScheduleTime: cronJob.status?.lastScheduleTime || null,
+            lastSuccessfulTime: cronJob.status?.lastSuccessfulTime || null,
+            creationTimestamp: cronJob.metadata?.creationTimestamp || "",
+            recentJobs: recentJobs,
+            jobTemplate: {
+                image: cronJob.spec?.jobTemplate?.spec?.template?.spec?.containers?.[0]
+                    ?.image || "",
+                command: cronJob.spec?.jobTemplate?.spec?.template?.spec?.containers?.[0]
+                    ?.command || [],
+                restartPolicy: cronJob.spec?.jobTemplate?.spec?.template?.spec?.restartPolicy || "",
+            },
+        };
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(cronJobDetails, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        console.error("Error describing CronJob:", {
+            status: error.response?.statusCode,
+            message: error.response?.body?.message || error.message,
+            details: error.response?.body,
+        });
+        throw error;
+    }
+}

package/dist/tools/get_job_logs.d.ts

@@ -0,0 +1,40 @@
+import { KubernetesManager } from "../types.js";
+export declare const getJobLogsSchema: {
+    readonly name: "get_job_logs";
+    readonly description: "Get logs from Pods created by a specific Job";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly name: {
+                readonly type: "string";
+                readonly description: "Name of the Job to get logs from";
+            };
+            readonly namespace: {
+                readonly type: "string";
+                readonly default: "default";
+            };
+            readonly tail: {
+                readonly type: "number";
+                readonly description: "Number of lines to return from the end of the logs";
+                readonly optional: true;
+            };
+            readonly timestamps: {
+                readonly type: "boolean";
+                readonly description: "Include timestamps in the logs";
+                readonly optional: true;
+            };
+        };
+        readonly required: readonly ["name", "namespace"];
+    };
+};
+export declare function getJobLogs(k8sManager: KubernetesManager, input: {
+    name: string;
+    namespace: string;
+    tail?: number;
+    timestamps?: boolean;
+}): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/tools/get_job_logs.js

@@ -0,0 +1,104 @@
+export const getJobLogsSchema = {
+    name: "get_job_logs",
+    description: "Get logs from Pods created by a specific Job",
+    inputSchema: {
+        type: "object",
+        properties: {
+            name: {
+                type: "string",
+                description: "Name of the Job to get logs from",
+            },
+            namespace: {
+                type: "string",
+                default: "default",
+            },
+            tail: {
+                type: "number",
+                description: "Number of lines to return from the end of the logs",
+                optional: true,
+            },
+            timestamps: {
+                type: "boolean",
+                description: "Include timestamps in the logs",
+                optional: true,
+            },
+        },
+        required: ["name", "namespace"],
+    },
+};
+export async function getJobLogs(k8sManager, input) {
+    try {
+        const coreApi = k8sManager.getCoreApi();
+        // First, get the job to check if it exists
+        const batchApi = k8sManager.getBatchApi();
+        await batchApi.readNamespacedJob(input.name, input.namespace);
+        // Find pods associated with this job
+        const labelSelector = `job-name=${input.name}`;
+        const { body: podList } = await coreApi.listNamespacedPod(input.namespace, undefined, // pretty
+        undefined, // allowWatchBookmarks
+        undefined, // _continue
+        undefined, // fieldSelector
+        labelSelector // labelSelector
+        );
+        if (podList.items.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            message: `No pods found for job ${input.name}`,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        // Get logs from all pods belonging to this job
+        const podLogs = await Promise.all(podList.items.map(async (pod) => {
+            const podName = pod.metadata?.name || "";
+            try {
+                const logResponse = await coreApi.readNamespacedPodLog(podName, input.namespace, undefined, // container
+                undefined, // follow
+                input.timestamps || false, // timestamps
+                undefined, // sinceSeconds
+                undefined, // sinceTime
+                (input.tail != undefined ? true : true) || undefined, // tailLines
+                undefined // pretty
+                );
+                return {
+                    podName,
+                    logs: logResponse.body,
+                    status: pod.status?.phase || "Unknown",
+                    startTime: pod.status?.startTime || null,
+                };
+            }
+            catch (error) {
+                return {
+                    podName,
+                    logs: `Error retrieving logs: ${error.message || "Unknown error"}`,
+                    status: pod.status?.phase || "Unknown",
+                    startTime: pod.status?.startTime || null,
+                };
+            }
+        }));
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        job: input.name,
+                        namespace: input.namespace,
+                        pods: podLogs,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        console.error("Error getting Job logs:", {
+            status: error.response?.statusCode,
+            message: error.response?.body?.message || error.message,
+            details: error.response?.body,
+        });
+        throw error;
+    }
+}

package/dist/tools/list_cronjobs.d.ts

@@ -0,0 +1,23 @@
+import { KubernetesManager } from "../types.js";
+export declare const listCronJobsSchema: {
+    readonly name: "list_cronjobs";
+    readonly description: "List CronJobs in a namespace";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly namespace: {
+                readonly type: "string";
+                readonly default: "default";
+            };
+        };
+        readonly required: readonly ["namespace"];
+    };
+};
+export declare function listCronJobs(k8sManager: KubernetesManager, input: {
+    namespace?: string;
+}): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/tools/list_cronjobs.js

@@ -0,0 +1,35 @@
+export const listCronJobsSchema = {
+    name: "list_cronjobs",
+    description: "List CronJobs in a namespace",
+    inputSchema: {
+        type: "object",
+        properties: {
+            namespace: { type: "string", default: "default" },
+        },
+        required: ["namespace"],
+    },
+};
+export async function listCronJobs(k8sManager, input) {
+    const namespace = input.namespace || "default";
+    // Get BatchV1Api from KubernetesManager
+    const batchV1Api = k8sManager.getBatchApi();
+    // List cronjobs in the specified namespace
+    const { body } = await batchV1Api.listNamespacedCronJob(namespace);
+    // Transform cronjob data to a more readable format
+    const cronjobs = body.items.map((cronjob) => ({
+        name: cronjob.metadata?.name || "",
+        namespace: cronjob.metadata?.namespace || "",
+        schedule: cronjob.spec?.schedule || "",
+        suspend: cronjob.spec?.suspend || false,
+        lastScheduleTime: cronjob.status?.lastScheduleTime || null,
+        createdAt: cronjob.metadata?.creationTimestamp,
+    }));
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({ cronjobs }, null, 2),
+            },
+        ],
+    };
+}

package/dist/tools/list_jobs.d.ts

@@ -0,0 +1,29 @@
+import { KubernetesManager } from "../types.js";
+export declare const listJobsSchema: {
+    readonly name: "list_jobs";
+    readonly description: "List Jobs in a namespace, optionally filtered by a CronJob parent";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly namespace: {
+                readonly type: "string";
+                readonly default: "default";
+            };
+            readonly cronJobName: {
+                readonly type: "string";
+                readonly description: "Optional: Filter jobs created by a specific CronJob";
+                readonly optional: true;
+            };
+        };
+        readonly required: readonly ["namespace"];
+    };
+};
+export declare function listJobs(k8sManager: KubernetesManager, input: {
+    namespace: string;
+    cronJobName?: string;
+}): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/tools/list_jobs.js

@@ -0,0 +1,77 @@
+export const listJobsSchema = {
+    name: "list_jobs",
+    description: "List Jobs in a namespace, optionally filtered by a CronJob parent",
+    inputSchema: {
+        type: "object",
+        properties: {
+            namespace: { type: "string", default: "default" },
+            cronJobName: {
+                type: "string",
+                description: "Optional: Filter jobs created by a specific CronJob",
+                optional: true,
+            },
+        },
+        required: ["namespace"],
+    },
+};
+export async function listJobs(k8sManager, input) {
+    try {
+        const namespace = input.namespace;
+        const batchV1Api = k8sManager.getBatchApi();
+        // Set up label selector if cronJobName is provided
+        let labelSelector;
+        if (input.cronJobName) {
+            labelSelector = `cronjob-name=${input.cronJobName}`;
+        }
+        // Get jobs with optional filtering
+        const { body } = await batchV1Api.listNamespacedJob(namespace, undefined, // pretty
+        undefined, // allowWatchBookmarks
+        undefined, // _continue
+        undefined, // fieldSelector
+        labelSelector // labelSelector
+        );
+        // Sort jobs by creation time (newest first)
+        const jobs = body.items.sort((a, b) => {
+            const aTime = a.metadata?.creationTimestamp
+                ? new Date(a.metadata.creationTimestamp)
+                : new Date(0);
+            const bTime = b.metadata?.creationTimestamp
+                ? new Date(b.metadata.creationTimestamp)
+                : new Date(0);
+            return bTime.getTime() - aTime.getTime();
+        });
+        // Transform job data to a more readable format
+        const formattedJobs = jobs.map((job) => ({
+            name: job.metadata?.name || "",
+            namespace: job.metadata?.namespace || "",
+            creationTime: job.metadata?.creationTimestamp || "",
+            labels: job.metadata?.labels || {},
+            completions: job.spec?.completions || 1,
+            parallelism: job.spec?.parallelism || 1,
+            status: {
+                active: job.status?.active || 0,
+                succeeded: job.status?.succeeded || 0,
+                failed: job.status?.failed || 0,
+                completionTime: job.status?.completionTime || null,
+                startTime: job.status?.startTime || null,
+                conditions: job.status?.conditions || [],
+            },
+        }));
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ jobs: formattedJobs }, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        console.error("Error listing Jobs:", {
+            status: error.response?.statusCode,
+            message: error.response?.body?.message || error.message,
+            details: error.response?.body,
+        });
+        throw error;
+    }
+}

package/dist/tools/scale_deployment.d.ts

@@ -0,0 +1,30 @@
+import { KubernetesManager } from "../types.js";
+export declare const scaleDeploymentSchema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            name: {
+                type: string;
+            };
+            namespace: {
+                type: string;
+            };
+            replicas: {
+                type: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function scaleDeployment(k8sManager: KubernetesManager, input: {
+    name: string;
+    namespace: string;
+    replicas: number;
+}): Promise<{
+    content: {
+        success: boolean;
+        message: string;
+    }[];
+}>;

package/dist/tools/scale_deployment.js

@@ -0,0 +1,50 @@
+export const scaleDeploymentSchema = {
+    name: "scale_deployment",
+    description: "Scale a Kubernetes deployment",
+    inputSchema: {
+        type: "object",
+        properties: {
+            name: { type: "string" },
+            namespace: { type: "string" },
+            replicas: { type: "number" }
+        },
+        required: ["name", "namespace", "replicas"]
+    }
+};
+export async function scaleDeployment(k8sManager, input) {
+    try {
+        const scale = k8sManager.getAppsApi().readNamespacedDeploymentScale(input.name, input.namespace);
+        (await scale).body.spec.replicas = input.replicas;
+        const result = await k8sManager.getAppsApi().replaceNamespacedDeploymentScale(input.name, input.namespace, (await scale).body);
+        if (result.response?.statusCode !== undefined && result.response.statusCode >= 200 && result.response.statusCode < 300) {
+            return {
+                content: [
+                    {
+                        success: true,
+                        message: `Scaled deployment ${input.name} to ${input.replicas} replicas`
+                    }
+                ]
+            };
+        }
+        else {
+            return {
+                content: [
+                    {
+                        success: false,
+                        message: `Failed to scale deployment ${input.name} to ${input.replicas} replicas`
+                    }
+                ]
+            };
+        }
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    success: false,
+                    message: `Failed to scale deployment ${error.message}`
+                }
+            ]
+        };
+    }
+}

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

@@ -7,6 +7,7 @@ export declare class KubernetesManager {
     private kc;
     private k8sApi;
     private k8sAppsApi;
+    private k8sBatchApi;
     constructor();
     cleanup(): Promise<void>;
     trackResource(kind: string, name: string, namespace: string): void;
@@ -18,4 +19,5 @@ export declare class KubernetesManager {
     getKubeConfig(): k8s.KubeConfig;
     getCoreApi(): k8s.CoreV1Api;
     getAppsApi(): k8s.AppsV1Api;
+    getBatchApi(): k8s.BatchV1Api;
 }

package/dist/utils/kubernetes-manager.js

@@ -6,11 +6,13 @@ export class KubernetesManager {
     kc;
     k8sApi;
     k8sAppsApi;
+    k8sBatchApi;
     constructor() {
         this.kc = new k8s.KubeConfig();
         this.kc.loadFromDefault();
         this.k8sApi = this.kc.makeApiClient(k8s.CoreV1Api);
         this.k8sAppsApi = this.kc.makeApiClient(k8s.AppsV1Api);
+        this.k8sBatchApi = this.kc.makeApiClient(k8s.BatchV1Api);
     }
     async cleanup() {
         // Stop watches
@@ -41,6 +43,9 @@ export class KubernetesManager {
             case "service":
                 await this.k8sApi.deleteNamespacedService(name, namespace);
                 break;
+            case "cronjob":
+                await this.k8sBatchApi.deleteNamespacedCronJob(name, namespace);
+                break;
         }
         this.resources = this.resources.filter((r) => !(r.kind === kind && r.name === name && r.namespace === namespace));
     }
@@ -65,4 +70,7 @@ export class KubernetesManager {
     getAppsApi() {
         return this.k8sAppsApi;
     }
+    getBatchApi() {
+        return this.k8sBatchApi;
+    }
 }

package/package.json

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