kubeview-mcp 1.0.0

package/src/tools/helm/HelmGetResourcesTool.ts

@@ -0,0 +1,140 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { HelmBaseTool, HelmCommonSchemas, executeHelmCommand } from './BaseTool.js';
+
+/**
+ * Get Kubernetes resources for a Helm release using helm get manifest and parse them
+ */
+export class HelmGetResourcesTool implements HelmBaseTool {
+  tool: Tool = {
+    name: 'helm_get_resources',
+    description: 'Get Kubernetes resources created by a Helm release with resource analysis',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        releaseName: HelmCommonSchemas.releaseName,
+        namespace: HelmCommonSchemas.namespace,
+        revision: HelmCommonSchemas.revision,
+        resourceType: {
+          type: 'string',
+          description:
+            'Filter by specific Kubernetes resource type (e.g., Pod, Service, Deployment)',
+          optional: true,
+        },
+      },
+      required: ['releaseName'],
+    },
+  };
+
+  async execute(params: any): Promise<any> {
+    try {
+      const args = ['get', 'manifest', params.releaseName];
+
+      // Add namespace parameter
+      if (params.namespace) {
+        args.push('--namespace', params.namespace);
+      }
+
+      // Add revision parameter
+      if (params.revision) {
+        args.push('--revision', params.revision.toString());
+      }
+
+      const result = await executeHelmCommand(args);
+
+      // Parse the YAML manifest to extract resource information
+      const manifestText = result.output || result;
+      const resources = this.parseKubernetesManifest(manifestText, params.resourceType);
+
+      return {
+        releaseName: params.releaseName,
+        namespace: params.namespace,
+        revision: params.revision,
+        totalResources: resources.length,
+        resourceTypes: this.getResourceTypeSummary(resources),
+        resources,
+      };
+    } catch (error: any) {
+      throw new Error(
+        `Failed to get resources for Helm release '${params.releaseName}': ${error.message}`,
+      );
+    }
+  }
+
+  private parseKubernetesManifest(manifestText: string, filterType?: string): any[] {
+    const resources: any[] = [];
+
+    if (!manifestText || typeof manifestText !== 'string') {
+      return resources;
+    }
+
+    // Split by YAML document separator
+    const documents = manifestText.split('---').filter((doc) => doc.trim());
+
+    for (const doc of documents) {
+      try {
+        // Simple YAML parsing for basic resource information
+        const resource = this.parseYamlDocument(doc);
+        if (resource && resource.kind && resource.metadata) {
+          // Filter by resource type if specified
+          if (!filterType || resource.kind.toLowerCase() === filterType.toLowerCase()) {
+            resources.push({
+              kind: resource.kind,
+              apiVersion: resource.apiVersion,
+              name: resource.metadata.name,
+              namespace: resource.metadata.namespace,
+              labels: resource.metadata.labels || {},
+              annotations: resource.metadata.annotations || {},
+            });
+          }
+        }
+      } catch {
+        // Skip invalid YAML documents
+        continue;
+      }
+    }
+
+    return resources;
+  }
+
+  private parseYamlDocument(yamlText: string): any {
+    // Simple YAML parser for basic fields - this is a basic implementation
+    // In a production environment, you'd want to use a proper YAML library
+    const lines = yamlText.trim().split('\n');
+    const resource: any = { metadata: {} };
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith('#')) continue;
+
+      if (trimmed.startsWith('kind:')) {
+        resource.kind = trimmed.split(':')[1].trim();
+      } else if (trimmed.startsWith('apiVersion:')) {
+        resource.apiVersion = trimmed.split(':')[1].trim();
+      } else if (trimmed.includes('name:') && !trimmed.includes('namespace:')) {
+        // Try to capture metadata.name
+        const match = trimmed.match(/name:\s*(.+)/);
+        if (match) {
+          resource.metadata.name = match[1].trim();
+        }
+      } else if (trimmed.includes('namespace:')) {
+        const match = trimmed.match(/namespace:\s*(.+)/);
+        if (match) {
+          resource.metadata.namespace = match[1].trim();
+        }
+      }
+    }
+
+    return resource.kind ? resource : null;
+  }
+
+  private getResourceTypeSummary(resources: any[]): Record<string, number> {
+    const summary: Record<string, number> = {};
+
+    for (const resource of resources) {
+      const kind = resource.kind;
+      summary[kind] = (summary[kind] || 0) + 1;
+    }
+
+    return summary;
+  }
+}

package/src/tools/helm/HelmGetValuesTool.ts

@@ -0,0 +1,62 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { HelmBaseTool, HelmCommonSchemas, executeHelmCommand } from './BaseTool.js';
+
+/**
+ * Get values for a Helm release
+ */
+export class HelmGetValuesTool implements HelmBaseTool {
+  tool: Tool = {
+    name: 'helm_get_values',
+    description: 'Get the values file for a named release (similar to `helm get values`)',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        releaseName: HelmCommonSchemas.releaseName,
+        namespace: HelmCommonSchemas.namespace,
+        revision: HelmCommonSchemas.revision,
+        outputFormat: {
+          ...HelmCommonSchemas.outputFormat,
+          default: 'yaml',
+        },
+        allValues: {
+          type: 'boolean',
+          description: 'Dump all (computed) values, not just the values provided to the chart',
+          optional: true,
+        },
+      },
+      required: ['releaseName'],
+    },
+  };
+
+  async execute(params: any): Promise<any> {
+    try {
+      const args = ['get', 'values', params.releaseName];
+
+      // Add namespace parameter
+      if (params.namespace) {
+        args.push('--namespace', params.namespace);
+      }
+
+      // Add revision parameter
+      if (params.revision) {
+        args.push('--revision', params.revision.toString());
+      }
+
+      // Add output format
+      const outputFormat = params.outputFormat || 'yaml';
+      args.push('--output', outputFormat);
+
+      // Add all values flag
+      if (params.allValues) {
+        args.push('--all');
+      }
+
+      const result = await executeHelmCommand(args);
+      return result;
+    } catch (error: any) {
+      throw new Error(
+        `Failed to get values for Helm release '${params.releaseName}': ${error.message}`,
+      );
+    }
+  }
+}

package/src/tools/helm/HelmHistoryTool.ts

@@ -0,0 +1,56 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { HelmBaseTool, HelmCommonSchemas, executeHelmCommand } from './BaseTool.js';
+
+/**
+ * Get history of a Helm release
+ */
+export class HelmHistoryTool implements HelmBaseTool {
+  tool: Tool = {
+    name: 'helm_history',
+    description: 'Fetch release history for a given release (similar to `helm history`)',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        releaseName: HelmCommonSchemas.releaseName,
+        namespace: HelmCommonSchemas.namespace,
+        outputFormat: {
+          ...HelmCommonSchemas.outputFormat,
+          default: 'json',
+        },
+        maxRevisions: {
+          type: 'number',
+          description: 'Maximum number of revisions to return (default: 256)',
+          optional: true,
+        },
+      },
+      required: ['releaseName'],
+    },
+  };
+
+  async execute(params: any): Promise<any> {
+    try {
+      const args = ['history', params.releaseName];
+
+      // Add namespace parameter
+      if (params.namespace) {
+        args.push('--namespace', params.namespace);
+      }
+
+      // Add output format
+      const outputFormat = params.outputFormat || 'json';
+      args.push('--output', outputFormat);
+
+      // Add max revisions
+      if (params.maxRevisions) {
+        args.push('--max', params.maxRevisions.toString());
+      }
+
+      const result = await executeHelmCommand(args);
+      return result;
+    } catch (error: any) {
+      throw new Error(
+        `Failed to get history for Helm release '${params.releaseName}': ${error.message}`,
+      );
+    }
+  }
+}

package/src/tools/helm/HelmListTool.ts

@@ -0,0 +1,107 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { HelmBaseTool, HelmCommonSchemas, executeHelmCommand } from './BaseTool.js';
+
+/**
+ * List Helm releases
+ */
+export class HelmListTool implements HelmBaseTool {
+  tool: Tool = {
+    name: 'helm_list',
+    description: 'List Helm releases in the cluster (similar to `helm list`)',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        namespace: HelmCommonSchemas.namespace,
+        allNamespaces: {
+          type: 'boolean',
+          description: 'List releases across all namespaces',
+          optional: true,
+        },
+        outputFormat: {
+          ...HelmCommonSchemas.outputFormat,
+          default: 'json',
+        },
+        selector: {
+          type: 'string',
+          description: 'Selector (label query) to filter on, supports =, ==, and !=',
+          optional: true,
+        },
+        maxReleases: {
+          type: 'number',
+          description: 'Maximum number of releases to return (default: 256)',
+          optional: true,
+        },
+        deployed: {
+          type: 'boolean',
+          description: 'Show deployed releases only',
+          optional: true,
+        },
+        failed: {
+          type: 'boolean',
+          description: 'Show failed releases only',
+          optional: true,
+        },
+        pending: {
+          type: 'boolean',
+          description: 'Show pending releases only',
+          optional: true,
+        },
+        superseded: {
+          type: 'boolean',
+          description: 'Show superseded releases only',
+          optional: true,
+        },
+        uninstalled: {
+          type: 'boolean',
+          description: 'Show uninstalled releases only',
+          optional: true,
+        },
+        uninstalling: {
+          type: 'boolean',
+          description: 'Show releases that are currently being uninstalled only',
+          optional: true,
+        },
+      },
+    },
+  };
+
+  async execute(params: any): Promise<any> {
+    try {
+      const args = ['list'];
+
+      // Add namespace parameter
+      if (params.namespace) {
+        args.push('--namespace', params.namespace);
+      } else if (params.allNamespaces) {
+        args.push('--all-namespaces');
+      }
+
+      // Add output format
+      const outputFormat = params.outputFormat || 'json';
+      args.push('--output', outputFormat);
+
+      // Add selector
+      if (params.selector) {
+        args.push('--selector', params.selector);
+      }
+
+      // Add max releases
+      if (params.maxReleases) {
+        args.push('--max', params.maxReleases.toString());
+      }
+
+      // Add status filters
+      if (params.deployed) args.push('--deployed');
+      if (params.failed) args.push('--failed');
+      if (params.pending) args.push('--pending');
+      if (params.superseded) args.push('--superseded');
+      if (params.uninstalled) args.push('--uninstalled');
+      if (params.uninstalling) args.push('--uninstalling');
+
+      const result = await executeHelmCommand(args);
+      return result;
+    } catch (error: any) {
+      throw new Error(`Failed to list Helm releases: ${error.message}`);
+    }
+  }
+}

package/src/tools/helm/HelmListWithResourcesTool.ts

@@ -0,0 +1,194 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { HelmBaseTool, HelmCommonSchemas, executeHelmCommand } from './BaseTool.js';
+
+/**
+ * List Helm releases with detailed Kubernetes resource information
+ */
+export class HelmListWithResourcesTool implements HelmBaseTool {
+  tool: Tool = {
+    name: 'helm_list_with_resources',
+    description: 'List Helm releases with detailed Kubernetes resource breakdown',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        namespace: HelmCommonSchemas.namespace,
+        allNamespaces: {
+          type: 'boolean',
+          description: 'List releases across all namespaces',
+          optional: true,
+        },
+        outputFormat: {
+          ...HelmCommonSchemas.outputFormat,
+          default: 'json',
+        },
+        includeResources: {
+          type: 'boolean',
+          description: 'Include detailed resource information for each release',
+          default: true,
+          optional: true,
+        },
+      },
+    },
+  };
+
+  async execute(params: any): Promise<any> {
+    try {
+      // First get the basic release list
+      const listArgs = ['list'];
+
+      // Add namespace parameter
+      if (params.namespace) {
+        listArgs.push('--namespace', params.namespace);
+      } else if (params.allNamespaces) {
+        listArgs.push('--all-namespaces');
+      }
+
+      // Add output format
+      const outputFormat = params.outputFormat || 'json';
+      listArgs.push('--output', outputFormat);
+
+      const listResult = await executeHelmCommand(listArgs);
+      const releases = Array.isArray(listResult) ? listResult : listResult.releases || [];
+
+      // If resource details are requested, enrich each release
+      if (params.includeResources !== false && releases.length > 0) {
+        for (const release of releases) {
+          try {
+            // Get manifest for each release to analyze resources
+            const manifestArgs = ['get', 'manifest', release.name];
+            if (release.namespace) {
+              manifestArgs.push('--namespace', release.namespace);
+            }
+
+            const manifestResult = await executeHelmCommand(manifestArgs);
+            const manifestText = manifestResult.output || manifestResult;
+            const resources = this.parseKubernetesManifest(manifestText);
+
+            release.resources = {
+              total: resources.length,
+              byType: this.getResourceTypeSummary(resources),
+              details: resources,
+            };
+          } catch (error: any) {
+            // If we can't get resources for a release, just note the error
+            release.resources = {
+              error: `Failed to get resources: ${error.message}`,
+            };
+          }
+        }
+      }
+
+      return {
+        totalReleases: releases.length,
+        releases,
+        summary: this.generateSummary(releases),
+      };
+    } catch (error: any) {
+      throw new Error(`Failed to list Helm releases with resources: ${error.message}`);
+    }
+  }
+
+  private parseKubernetesManifest(manifestText: string): any[] {
+    const resources: any[] = [];
+
+    if (!manifestText || typeof manifestText !== 'string') {
+      return resources;
+    }
+
+    // Split by YAML document separator
+    const documents = manifestText.split('---').filter((doc) => doc.trim());
+
+    for (const doc of documents) {
+      try {
+        // Simple YAML parsing for basic resource information
+        const resource = this.parseYamlDocument(doc);
+        if (resource && resource.kind && resource.metadata) {
+          resources.push({
+            kind: resource.kind,
+            apiVersion: resource.apiVersion,
+            name: resource.metadata.name,
+            namespace: resource.metadata.namespace,
+          });
+        }
+      } catch {
+        // Skip invalid YAML documents
+        continue;
+      }
+    }
+
+    return resources;
+  }
+
+  private parseYamlDocument(yamlText: string): any {
+    // Simple YAML parser for basic fields
+    const lines = yamlText.trim().split('\n');
+    const resource: any = { metadata: {} };
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith('#')) continue;
+
+      if (trimmed.startsWith('kind:')) {
+        resource.kind = trimmed.split(':')[1].trim();
+      } else if (trimmed.startsWith('apiVersion:')) {
+        resource.apiVersion = trimmed.split(':')[1].trim();
+      } else if (trimmed.includes('name:') && !trimmed.includes('namespace:')) {
+        const match = trimmed.match(/name:\s*(.+)/);
+        if (match) {
+          resource.metadata.name = match[1].trim();
+        }
+      } else if (trimmed.includes('namespace:')) {
+        const match = trimmed.match(/namespace:\s*(.+)/);
+        if (match) {
+          resource.metadata.namespace = match[1].trim();
+        }
+      }
+    }
+
+    return resource.kind ? resource : null;
+  }
+
+  private getResourceTypeSummary(resources: any[]): Record<string, number> {
+    const summary: Record<string, number> = {};
+
+    for (const resource of resources) {
+      const kind = resource.kind;
+      summary[kind] = (summary[kind] || 0) + 1;
+    }
+
+    return summary;
+  }
+
+  private generateSummary(releases: any[]): any {
+    const summary = {
+      totalReleases: releases.length,
+      byStatus: {} as Record<string, number>,
+      byNamespace: {} as Record<string, number>,
+      totalResources: 0,
+      resourceTypes: {} as Record<string, number>,
+    };
+
+    for (const release of releases) {
+      // Count by status
+      const status = release.status || 'unknown';
+      summary.byStatus[status] = (summary.byStatus[status] || 0) + 1;
+
+      // Count by namespace
+      const namespace = release.namespace || 'default';
+      summary.byNamespace[namespace] = (summary.byNamespace[namespace] || 0) + 1;
+
+      // Aggregate resource information
+      if (release.resources && release.resources.total) {
+        summary.totalResources += release.resources.total;
+
+        if (release.resources.byType) {
+          for (const [type, count] of Object.entries(release.resources.byType)) {
+            summary.resourceTypes[type] = (summary.resourceTypes[type] || 0) + (count as number);
+          }
+        }
+      }
+    }
+
+    return summary;
+  }
+}

package/src/tools/helm/HelmStatusTool.ts

@@ -0,0 +1,62 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { HelmBaseTool, HelmCommonSchemas, executeHelmCommand } from './BaseTool.js';
+
+/**
+ * Get status of a Helm release
+ */
+export class HelmStatusTool implements HelmBaseTool {
+  tool: Tool = {
+    name: 'helm_status',
+    description: 'Display the status of the named release (similar to `helm status`)',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        releaseName: HelmCommonSchemas.releaseName,
+        namespace: HelmCommonSchemas.namespace,
+        revision: HelmCommonSchemas.revision,
+        outputFormat: {
+          ...HelmCommonSchemas.outputFormat,
+          default: 'json',
+        },
+        showResources: {
+          type: 'boolean',
+          description: 'Show the resources this release created',
+          optional: true,
+        },
+      },
+      required: ['releaseName'],
+    },
+  };
+
+  async execute(params: any): Promise<any> {
+    try {
+      const args = ['status', params.releaseName];
+
+      // Add namespace parameter
+      if (params.namespace) {
+        args.push('--namespace', params.namespace);
+      }
+
+      // Add revision parameter
+      if (params.revision) {
+        args.push('--revision', params.revision.toString());
+      }
+
+      // Add output format
+      const outputFormat = params.outputFormat || 'json';
+      args.push('--output', outputFormat);
+
+      // Add show resources flag
+      if (params.showResources) {
+        args.push('--show-resources');
+      }
+
+      const result = await executeHelmCommand(args);
+      return result;
+    } catch (error: any) {
+      throw new Error(
+        `Failed to get status for Helm release '${params.releaseName}': ${error.message}`,
+      );
+    }
+  }
+}

package/src/tools/helm/index.ts

@@ -0,0 +1,11 @@
+export type { HelmBaseTool } from './BaseTool.js';
+export { HelmCommonSchemas, executeHelmCommand, validateHelmCLI } from './BaseTool.js';
+export { HelmListTool } from './HelmListTool.js';
+export { HelmGetValuesTool } from './HelmGetValuesTool.js';
+export { HelmGetManifestTool } from './HelmGetManifestTool.js';
+export { HelmGetNotesTool } from './HelmGetNotesTool.js';
+export { HelmGetHooksTool } from './HelmGetHooksTool.js';
+export { HelmStatusTool } from './HelmStatusTool.js';
+export { HelmHistoryTool } from './HelmHistoryTool.js';
+export { HelmGetResourcesTool } from './HelmGetResourcesTool.js';
+export { HelmListWithResourcesTool } from './HelmListWithResourcesTool.js';