kubeview-mcp 1.0.0

package/src/kubernetes/resources/CustomResourceOperations.ts

@@ -0,0 +1,392 @@
+import * as k8s from '@kubernetes/client-node';
+import {
+  BaseResourceOperations,
+  ResourceOperationOptions,
+  WatchCallback,
+  WatchEventType,
+} from '../BaseResourceOperations.js';
+import { KubernetesClient } from '../KubernetesClient.js';
+
+/**
+ * Custom Resource operations implementation
+ */
+export class CustomResourceOperations<
+  T extends k8s.KubernetesObject,
+> extends BaseResourceOperations<T> {
+  private customObjectsApi: k8s.CustomObjectsApi;
+
+  constructor(
+    client: KubernetesClient,
+    private group: string,
+    private version: string,
+    private plural: string,
+    private namespaced: boolean = true,
+  ) {
+    super(client, plural);
+    this.customObjectsApi = client.kubeConfig.makeApiClient(k8s.CustomObjectsApi);
+  }
+
+  /**
+   * Create a new custom resource
+   */
+  async create(resource: T, options?: ResourceOperationOptions): Promise<T> {
+    try {
+      const namespace = options?.namespace || resource.metadata?.namespace || 'default';
+
+      let response;
+      if (this.namespaced) {
+        response = await this.customObjectsApi.createNamespacedCustomObject({
+          group: this.group,
+          version: this.version,
+          namespace,
+          plural: this.plural,
+          body: resource,
+        });
+      } else {
+        response = await this.customObjectsApi.createClusterCustomObject({
+          group: this.group,
+          version: this.version,
+          plural: this.plural,
+          body: resource,
+        });
+      }
+
+      this.logger?.info(
+        `Created custom resource '${resource.metadata?.name}' of type '${this.plural}'`,
+      );
+      return response as T;
+    } catch (error) {
+      this.handleApiError(error, 'Create', resource.metadata?.name);
+    }
+  }
+
+  /**
+   * Get a custom resource by name
+   */
+  async get(name: string, options?: ResourceOperationOptions): Promise<T> {
+    try {
+      const namespace = options?.namespace || 'default';
+
+      let response;
+      if (this.namespaced) {
+        response = await this.customObjectsApi.getNamespacedCustomObject({
+          group: this.group,
+          version: this.version,
+          namespace,
+          plural: this.plural,
+          name,
+        });
+      } else {
+        response = await this.customObjectsApi.getClusterCustomObject({
+          group: this.group,
+          version: this.version,
+          plural: this.plural,
+          name,
+        });
+      }
+
+      return response as T;
+    } catch (error) {
+      this.handleApiError(error, 'Get', name);
+    }
+  }
+
+  /**
+   * Update a custom resource
+   */
+  async update(resource: T, options?: ResourceOperationOptions): Promise<T> {
+    try {
+      const namespace = options?.namespace || resource.metadata?.namespace || 'default';
+      const name = resource.metadata?.name;
+      if (!name) {
+        throw new Error('Resource name is required for update');
+      }
+
+      let response;
+      if (this.namespaced) {
+        response = await this.customObjectsApi.replaceNamespacedCustomObject({
+          group: this.group,
+          version: this.version,
+          namespace,
+          plural: this.plural,
+          name,
+          body: resource,
+        });
+      } else {
+        response = await this.customObjectsApi.replaceClusterCustomObject({
+          group: this.group,
+          version: this.version,
+          plural: this.plural,
+          name,
+          body: resource,
+        });
+      }
+
+      this.logger?.info(`Updated custom resource '${name}' of type '${this.plural}'`);
+      return response as T;
+    } catch (error) {
+      this.handleApiError(error, 'Update', resource.metadata?.name);
+    }
+  }
+
+  /**
+   * Patch a custom resource
+   */
+  async patch(name: string, patch: any, options?: ResourceOperationOptions): Promise<T> {
+    try {
+      const namespace = options?.namespace || 'default';
+
+      let response;
+      if (this.namespaced) {
+        response = await this.customObjectsApi.patchNamespacedCustomObject({
+          group: this.group,
+          version: this.version,
+          namespace,
+          plural: this.plural,
+          name,
+          body: patch,
+        });
+      } else {
+        response = await this.customObjectsApi.patchClusterCustomObject({
+          group: this.group,
+          version: this.version,
+          plural: this.plural,
+          name,
+          body: patch,
+        });
+      }
+
+      this.logger?.info(`Patched custom resource '${name}' of type '${this.plural}'`);
+      return response as T;
+    } catch (error) {
+      this.handleApiError(error, 'Patch', name);
+    }
+  }
+
+  /**
+   * Delete a custom resource
+   */
+  async delete(name: string, options?: ResourceOperationOptions): Promise<void> {
+    try {
+      const namespace = options?.namespace || 'default';
+      const deleteOptions = this.buildDeleteOptions(options);
+
+      if (this.namespaced) {
+        await this.customObjectsApi.deleteNamespacedCustomObject({
+          group: this.group,
+          version: this.version,
+          namespace,
+          plural: this.plural,
+          name,
+          body: deleteOptions,
+        });
+      } else {
+        await this.customObjectsApi.deleteClusterCustomObject({
+          group: this.group,
+          version: this.version,
+          plural: this.plural,
+          name,
+          body: deleteOptions,
+        });
+      }
+
+      this.logger?.info(`Deleted custom resource '${name}' of type '${this.plural}'`);
+    } catch (error) {
+      this.handleApiError(error, 'Delete', name);
+    }
+  }
+
+  /**
+   * List custom resources
+   */
+  async list(options?: ResourceOperationOptions): Promise<k8s.KubernetesListObject<T>> {
+    try {
+      const namespace = options?.namespace;
+      const listOptions = this.buildListOptions(options);
+
+      let response;
+      if (this.namespaced && namespace) {
+        response = await this.customObjectsApi.listNamespacedCustomObject({
+          group: this.group,
+          version: this.version,
+          namespace,
+          plural: this.plural,
+          pretty: listOptions.pretty,
+          allowWatchBookmarks: listOptions.allowWatchBookmarks,
+          _continue: listOptions.continue,
+          fieldSelector: listOptions.fieldSelector,
+          labelSelector: listOptions.labelSelector,
+          limit: listOptions.limit,
+          resourceVersion: listOptions.resourceVersion,
+          resourceVersionMatch: listOptions.resourceVersionMatch,
+          timeoutSeconds: listOptions.timeoutSeconds,
+          watch: listOptions.watch,
+        });
+      } else {
+        response = await this.customObjectsApi.listClusterCustomObject({
+          group: this.group,
+          version: this.version,
+          plural: this.plural,
+          pretty: listOptions.pretty,
+          allowWatchBookmarks: listOptions.allowWatchBookmarks,
+          _continue: listOptions.continue,
+          fieldSelector: listOptions.fieldSelector,
+          labelSelector: listOptions.labelSelector,
+          limit: listOptions.limit,
+          resourceVersion: listOptions.resourceVersion,
+          resourceVersionMatch: listOptions.resourceVersionMatch,
+          timeoutSeconds: listOptions.timeoutSeconds,
+          watch: listOptions.watch,
+        });
+      }
+
+      return response as k8s.KubernetesListObject<T>;
+    } catch (error) {
+      this.handleApiError(error, 'List');
+    }
+  }
+
+  /**
+   * Watch custom resources for changes
+   */
+  watch(callback: WatchCallback<T>, options?: ResourceOperationOptions): () => void {
+    const namespace = options?.namespace;
+    const watch = new k8s.Watch(this.client.kubeConfig);
+    let aborted = false;
+
+    const startWatch = async () => {
+      try {
+        const path =
+          this.namespaced && namespace
+            ? `/apis/${this.group}/${this.version}/namespaces/${namespace}/${this.plural}`
+            : `/apis/${this.group}/${this.version}/${this.plural}`;
+
+        const req = await watch.watch(
+          path,
+          this.buildListOptions(options),
+          (type: string, obj: T) => {
+            if (!aborted) {
+              callback({
+                type: type as WatchEventType,
+                object: obj,
+              });
+            }
+          },
+          (err: any) => {
+            if (!aborted) {
+              this.logger?.error(`Watch error for custom resources (${this.plural}): ${err}`);
+              callback({
+                type: WatchEventType.ERROR,
+                object: err,
+              });
+            }
+          },
+        );
+
+        return req;
+      } catch (error) {
+        this.logger?.error(`Failed to start watch for custom resources (${this.plural}): ${error}`);
+        throw error;
+      }
+    };
+
+    let request: any;
+    startWatch().then((req) => {
+      request = req;
+    });
+
+    return () => {
+      aborted = true;
+      if (request) {
+        request.abort();
+      }
+    };
+  }
+
+  /**
+   * Get the custom resource's status subresource
+   */
+  async getStatus(name: string, options?: ResourceOperationOptions): Promise<any> {
+    try {
+      const namespace = options?.namespace || 'default';
+
+      let response;
+      if (this.namespaced) {
+        response = await this.customObjectsApi.getNamespacedCustomObjectStatus({
+          group: this.group,
+          version: this.version,
+          namespace,
+          plural: this.plural,
+          name,
+        });
+      } else {
+        response = await this.customObjectsApi.getClusterCustomObjectStatus({
+          group: this.group,
+          version: this.version,
+          plural: this.plural,
+          name,
+        });
+      }
+
+      return response;
+    } catch (error) {
+      this.handleApiError(error, 'GetStatus', name);
+    }
+  }
+
+  /**
+   * Update the custom resource's status subresource
+   */
+  async updateStatus(name: string, status: any, options?: ResourceOperationOptions): Promise<T> {
+    try {
+      const namespace = options?.namespace || 'default';
+      const resource = await this.get(name, options);
+      (resource as any).status = status;
+
+      let response;
+      if (this.namespaced) {
+        response = await this.customObjectsApi.replaceNamespacedCustomObjectStatus({
+          group: this.group,
+          version: this.version,
+          namespace,
+          plural: this.plural,
+          name,
+          body: resource,
+        });
+      } else {
+        response = await this.customObjectsApi.replaceClusterCustomObjectStatus({
+          group: this.group,
+          version: this.version,
+          plural: this.plural,
+          name,
+          body: resource,
+        });
+      }
+
+      this.logger?.info(`Updated status for custom resource '${name}' of type '${this.plural}'`);
+      return response as T;
+    } catch (error) {
+      this.handleApiError(error, 'UpdateStatus', name);
+    }
+  }
+
+  /**
+   * Check if a Custom Resource Definition exists
+   */
+  async crdExists(): Promise<boolean> {
+    try {
+      const apiExtensions = this.client.kubeConfig.makeApiClient(k8s.ApiextensionsV1Api);
+      const crdName = `${this.plural}.${this.group}`;
+
+      await apiExtensions.readCustomResourceDefinition({
+        name: crdName,
+      });
+      return true;
+    } catch (error) {
+      if ((error as any).response?.statusCode === 404) {
+        return false;
+      }
+      throw error;
+    }
+  }
+}

package/src/kubernetes/resources/DeploymentOperations.ts

@@ -0,0 +1,294 @@
+import * as k8s from '@kubernetes/client-node';
+import {
+  BaseResourceOperations,
+  ResourceOperationOptions,
+  WatchCallback,
+  WatchEventType,
+} from '../BaseResourceOperations.js';
+import { KubernetesClient } from '../KubernetesClient.js';
+
+/**
+ * Deployment-specific operation options
+ */
+export interface DeploymentOperationOptions extends ResourceOperationOptions {
+  /**
+   * Number of seconds to wait for deployment to be ready
+   */
+  timeoutSeconds?: number;
+}
+
+/**
+ * Deployment operations implementation - Read-only operations
+ */
+export class DeploymentOperations extends BaseResourceOperations<k8s.V1Deployment> {
+  constructor(client: KubernetesClient) {
+    super(client, 'Deployment');
+  }
+
+  /**
+   * @throws {Error} This operation is not supported in read-only mode
+   */
+  async create(
+    _deployment: k8s.V1Deployment,
+    _options?: ResourceOperationOptions,
+  ): Promise<k8s.V1Deployment> {
+    throw new Error('Create operation is not supported in read-only mode');
+  }
+
+  /**
+   * @throws {Error} This operation is not supported in read-only mode
+   */
+  async update(
+    _deployment: k8s.V1Deployment,
+    _options?: ResourceOperationOptions,
+  ): Promise<k8s.V1Deployment> {
+    throw new Error('Update operation is not supported in read-only mode');
+  }
+
+  /**
+   * @throws {Error} This operation is not supported in read-only mode
+   */
+  async patch(
+    _name: string,
+    _patch: any,
+    _options?: ResourceOperationOptions,
+  ): Promise<k8s.V1Deployment> {
+    throw new Error('Patch operation is not supported in read-only mode');
+  }
+
+  /**
+   * @throws {Error} This operation is not supported in read-only mode
+   */
+  async delete(_name: string, _options?: ResourceOperationOptions): Promise<void> {
+    throw new Error('Delete operation is not supported in read-only mode');
+  }
+
+  /**
+   * Get a deployment by name
+   */
+  async get(name: string, options?: ResourceOperationOptions): Promise<k8s.V1Deployment> {
+    try {
+      const namespace = options?.namespace || 'default';
+      const response = await this.client.apps.readNamespacedDeployment({
+        name,
+        namespace,
+      });
+      return response;
+    } catch (error) {
+      this.handleApiError(error, 'Get', name);
+    }
+  }
+
+  /**
+   * List deployments
+   */
+  async list(options?: ResourceOperationOptions): Promise<k8s.V1DeploymentList> {
+    try {
+      const namespace = options?.namespace;
+      const listOptions = this.buildListOptions(options);
+
+      let response;
+      if (namespace) {
+        response = await this.client.apps.listNamespacedDeployment({
+          namespace,
+          pretty: listOptions.pretty,
+          allowWatchBookmarks: listOptions.allowWatchBookmarks,
+          _continue: listOptions.continue,
+          fieldSelector: listOptions.fieldSelector,
+          labelSelector: listOptions.labelSelector,
+          limit: listOptions.limit,
+          resourceVersion: listOptions.resourceVersion,
+          resourceVersionMatch: listOptions.resourceVersionMatch,
+          sendInitialEvents: listOptions.sendInitialEvents,
+          timeoutSeconds: listOptions.timeoutSeconds,
+          watch: listOptions.watch,
+        });
+      } else {
+        response = await this.client.apps.listDeploymentForAllNamespaces({
+          allowWatchBookmarks: listOptions.allowWatchBookmarks,
+          _continue: listOptions.continue,
+          fieldSelector: listOptions.fieldSelector,
+          labelSelector: listOptions.labelSelector,
+          limit: listOptions.limit,
+          pretty: listOptions.pretty,
+          resourceVersion: listOptions.resourceVersion,
+          resourceVersionMatch: listOptions.resourceVersionMatch,
+          sendInitialEvents: listOptions.sendInitialEvents,
+          timeoutSeconds: listOptions.timeoutSeconds,
+          watch: listOptions.watch,
+        });
+      }
+
+      return response;
+    } catch (error) {
+      this.handleApiError(error, 'List');
+    }
+  }
+
+  /**
+   * Watch deployments for changes
+   */
+  watch(callback: WatchCallback<k8s.V1Deployment>, options?: ResourceOperationOptions): () => void {
+    const namespace = options?.namespace;
+    const watch = new k8s.Watch(this.client.kubeConfig);
+    let aborted = false;
+
+    const startWatch = async () => {
+      try {
+        const req = await watch.watch(
+          `/apis/apps/v1/${namespace ? `namespaces/${namespace}/` : ''}deployments`,
+          this.buildListOptions(options),
+          (type: string, obj: k8s.V1Deployment) => {
+            if (!aborted) {
+              callback({
+                type: type as WatchEventType,
+                object: obj,
+              });
+            }
+          },
+          (err: any) => {
+            if (!aborted) {
+              this.logger?.error(`Watch error for deployments: ${err}`);
+              callback({
+                type: WatchEventType.ERROR,
+                object: err,
+              });
+            }
+          },
+        );
+
+        return req;
+      } catch (error) {
+        this.logger?.error(`Failed to start watch for deployments: ${error}`);
+        throw error;
+      }
+    };
+
+    let request: any;
+    startWatch().then((req) => {
+      request = req;
+    });
+
+    return () => {
+      aborted = true;
+      if (request) {
+        request.abort();
+      }
+    };
+  }
+
+  /**
+   * Get deployment status
+   */
+  async getStatus(
+    name: string,
+    options?: ResourceOperationOptions,
+  ): Promise<k8s.V1DeploymentStatus | undefined> {
+    try {
+      const namespace = options?.namespace || 'default';
+      const response = await this.client.apps.readNamespacedDeploymentStatus({
+        name,
+        namespace,
+      });
+      return response.status;
+    } catch (error) {
+      this.handleApiError(error, 'GetStatus', name);
+    }
+  }
+
+  /**
+   * Wait for deployment to be ready
+   */
+  async waitForReady(name: string, options?: DeploymentOperationOptions): Promise<boolean> {
+    const timeoutSeconds = options?.timeoutSeconds || 300;
+    const startTime = Date.now();
+    const timeoutTime = startTime + timeoutSeconds * 1000;
+
+    while (Date.now() < timeoutTime) {
+      try {
+        const namespace = options?.namespace || 'default';
+        const response = await this.client.apps.readNamespacedDeploymentStatus({
+          name,
+          namespace,
+        });
+        const status = response.status;
+
+        if (
+          status?.availableReplicas === status?.replicas &&
+          status?.updatedReplicas === status?.replicas &&
+          status?.readyReplicas === status?.replicas
+        ) {
+          return true;
+        }
+
+        await new Promise((resolve) => setTimeout(resolve, 2000)); // Wait 2 seconds before checking again
+      } catch (error) {
+        this.logger?.error(`Error waiting for deployment '${name}' to be ready: ${error}`);
+        throw error;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Get a deployment with MCP tool-friendly formatting
+   */
+  async getFormatted(
+    name: string,
+    options?: ResourceOperationOptions,
+  ): Promise<{
+    resourceType: string;
+    metadata: any;
+    spec: any;
+    status: any;
+  }> {
+    try {
+      const deployment = await this.get(name, options);
+
+      return {
+        resourceType: 'deployment',
+        metadata: this.formatResourceMetadata(deployment),
+        spec: {
+          replicas: deployment.spec?.replicas,
+          selector: deployment.spec?.selector,
+          template: deployment.spec?.template,
+          strategy: deployment.spec?.strategy,
+          minReadySeconds: deployment.spec?.minReadySeconds,
+          revisionHistoryLimit: deployment.spec?.revisionHistoryLimit,
+          progressDeadlineSeconds: deployment.spec?.progressDeadlineSeconds,
+        },
+        status: {
+          ...this.formatResourceStatus(deployment),
+          replicas: deployment.status?.replicas,
+          updatedReplicas: deployment.status?.updatedReplicas,
+          readyReplicas: deployment.status?.readyReplicas,
+          availableReplicas: deployment.status?.availableReplicas,
+          unavailableReplicas: deployment.status?.unavailableReplicas,
+          observedGeneration: deployment.status?.observedGeneration,
+        },
+      };
+    } catch (error) {
+      this.handleApiError(error, 'GetFormatted', name);
+    }
+  }
+
+  private formatResourceMetadata(resource: any): any {
+    return {
+      name: resource.metadata?.name,
+      namespace: resource.metadata?.namespace,
+      uid: resource.metadata?.uid,
+      resourceVersion: resource.metadata?.resourceVersion,
+      generation: resource.metadata?.generation,
+      creationTimestamp: resource.metadata?.creationTimestamp,
+      labels: resource.metadata?.labels || {},
+      annotations: resource.metadata?.annotations || {},
+    };
+  }
+
+  private formatResourceStatus(resource: any): any {
+    return {
+      conditions: resource.status?.conditions || [],
+    };
+  }
+}