kubeview-mcp 1.0.0

package/src/tools/argocd/ArgoCDAppLogsTool.ts

@@ -0,0 +1,162 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { ArgoCDBaseTool, ArgoCDCommonSchemas, executeArgoCDCommand } from './BaseTool.js';
+
+/**
+ * Get logs of an ArgoCD application
+ */
+export class ArgoCDAppLogsTool implements ArgoCDBaseTool {
+  tool: Tool = {
+    name: 'argocd_app_logs',
+    description: 'Get logs of an ArgoCD application (similar to `argocd app logs <app-name>`)',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        appName: {
+          ...ArgoCDCommonSchemas.appName,
+          optional: false,
+        },
+        container: {
+          type: 'string',
+          description: 'Container name to get logs from',
+          optional: true,
+        },
+        follow: {
+          type: 'boolean',
+          description: 'Follow log output (stream logs)',
+          optional: true,
+        },
+        group: {
+          type: 'string',
+          description: 'Resource group',
+          optional: true,
+        },
+        kind: {
+          type: 'string',
+          description: 'Resource kind (e.g., Pod, Deployment)',
+          optional: true,
+        },
+        name: {
+          type: 'string',
+          description: 'Resource name',
+          optional: true,
+        },
+        namespace: {
+          type: 'string',
+          description: 'Resource namespace',
+          optional: true,
+        },
+        previous: {
+          type: 'boolean',
+          description: 'Get logs from previous instance',
+          optional: true,
+        },
+        since: {
+          type: 'string',
+          description: 'Show logs since duration (e.g., 1h, 30m, 10s)',
+          optional: true,
+        },
+        sinceTime: {
+          type: 'string',
+          description: 'Show logs since timestamp (RFC3339)',
+          optional: true,
+        },
+        tail: {
+          type: 'number',
+          description: 'Number of lines to show from the end of the logs',
+          optional: true,
+        },
+        timestamps: {
+          type: 'boolean',
+          description: 'Include timestamps in log output',
+          optional: true,
+        },
+        server: ArgoCDCommonSchemas.server,
+        grpcWeb: ArgoCDCommonSchemas.grpcWeb,
+        plaintext: ArgoCDCommonSchemas.plaintext,
+        insecure: ArgoCDCommonSchemas.insecure,
+      },
+      required: ['appName'],
+    },
+  };
+
+  async execute(params: any): Promise<any> {
+    const args = ['app', 'logs', params.appName];
+
+    // Add container specification
+    if (params.container) {
+      args.push('--container', params.container);
+    }
+
+    // Add follow option
+    if (params.follow) {
+      args.push('--follow');
+    }
+
+    // Add resource specification
+    if (params.group) {
+      args.push('--group', params.group);
+    }
+
+    if (params.kind) {
+      args.push('--kind', params.kind);
+    }
+
+    if (params.name) {
+      args.push('--name', params.name);
+    }
+
+    if (params.namespace) {
+      args.push('--namespace', params.namespace);
+    }
+
+    // Add previous logs option
+    if (params.previous) {
+      args.push('--previous');
+    }
+
+    // Add time-based filters
+    if (params.since) {
+      args.push('--since', params.since);
+    }
+
+    if (params.sinceTime) {
+      args.push('--since-time', params.sinceTime);
+    }
+
+    // Add tail option
+    if (params.tail) {
+      args.push('--tail', params.tail.toString());
+    }
+
+    // Add timestamps option
+    if (params.timestamps) {
+      args.push('--timestamps');
+    }
+
+    // Add server configuration
+    if (params.server) {
+      args.push('--server', params.server);
+    }
+
+    if (params.grpcWeb) {
+      args.push('--grpc-web');
+    }
+
+    if (params.plaintext) {
+      args.push('--plaintext');
+    }
+
+    if (params.insecure) {
+      args.push('--insecure');
+    }
+
+    try {
+      const result = await executeArgoCDCommand(args);
+      return result;
+    } catch (error) {
+      throw new Error(
+        `Failed to get ArgoCD application logs for "${params.appName}": ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+}

package/src/tools/argocd/ArgoCDAppResourcesTool.ts

@@ -0,0 +1,139 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { ArgoCDBaseTool, ArgoCDCommonSchemas, executeArgoCDCommand } from './BaseTool.js';
+
+/**
+ * List resources of an ArgoCD application
+ */
+export class ArgoCDAppResourcesTool implements ArgoCDBaseTool {
+  tool: Tool = {
+    name: 'argocd_app_resources',
+    description:
+      'List resources of an ArgoCD application (similar to `argocd app resources <app-name>`)',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        appName: {
+          ...ArgoCDCommonSchemas.appName,
+          optional: false,
+        },
+        outputFormat: {
+          type: 'string',
+          description: 'Output format for application resources. Supports: json, yaml, wide, tree',
+          enum: ['json', 'yaml', 'wide', 'tree'],
+          optional: true,
+          default: 'json',
+        },
+        orphaned: {
+          type: 'boolean',
+          description: 'Show orphaned resources only',
+          optional: true,
+        },
+        group: {
+          type: 'string',
+          description: 'Filter by resource group',
+          optional: true,
+        },
+        kind: {
+          type: 'string',
+          description: 'Filter by resource kind (e.g., Pod, Deployment, Service)',
+          optional: true,
+        },
+        name: {
+          type: 'string',
+          description: 'Filter by resource name',
+          optional: true,
+        },
+        namespace: {
+          type: 'string',
+          description: 'Filter by resource namespace',
+          optional: true,
+        },
+        health: {
+          type: 'string',
+          description: 'Filter by health status',
+          enum: ['Healthy', 'Progressing', 'Degraded', 'Suspended', 'Missing', 'Unknown'],
+          optional: true,
+        },
+        syncStatus: {
+          type: 'string',
+          description: 'Filter by sync status',
+          enum: ['Synced', 'OutOfSync', 'Unknown'],
+          optional: true,
+        },
+        server: ArgoCDCommonSchemas.server,
+        grpcWeb: ArgoCDCommonSchemas.grpcWeb,
+        plaintext: ArgoCDCommonSchemas.plaintext,
+        insecure: ArgoCDCommonSchemas.insecure,
+      },
+      required: ['appName'],
+    },
+  };
+
+  async execute(params: any): Promise<any> {
+    const args = ['app', 'resources', params.appName];
+
+    // Add output format
+    if (params.outputFormat) {
+      args.push('-o', params.outputFormat);
+    } else {
+      args.push('-o', 'json');
+    }
+
+    // Add orphaned resources filter
+    if (params.orphaned) {
+      args.push('--orphaned');
+    }
+
+    // Add resource filters
+    if (params.group) {
+      args.push('--group', params.group);
+    }
+
+    if (params.kind) {
+      args.push('--kind', params.kind);
+    }
+
+    if (params.name) {
+      args.push('--name', params.name);
+    }
+
+    if (params.namespace) {
+      args.push('--namespace', params.namespace);
+    }
+
+    // Add status filters
+    if (params.health) {
+      args.push('--health', params.health);
+    }
+
+    if (params.syncStatus) {
+      args.push('--sync-status', params.syncStatus);
+    }
+
+    // Add server configuration
+    if (params.server) {
+      args.push('--server', params.server);
+    }
+
+    if (params.grpcWeb) {
+      args.push('--grpc-web');
+    }
+
+    if (params.plaintext) {
+      args.push('--plaintext');
+    }
+
+    if (params.insecure) {
+      args.push('--insecure');
+    }
+
+    try {
+      const result = await executeArgoCDCommand(args);
+      return result;
+    } catch (error) {
+      throw new Error(
+        `Failed to get ArgoCD application resources for "${params.appName}": ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+}

package/src/tools/argocd/BaseTool.ts

@@ -0,0 +1,83 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { executeCliCommand, validateCli } from '../../utils/CliUtils.js';
+
+/**
+ * Base interface for all ArgoCD MCP tool commands
+ */
+export interface ArgoCDBaseTool {
+  /**
+   * The tool definition for MCP registration
+   */
+  tool: Tool;
+
+  /**
+   * Execute the command with given parameters
+   */
+  execute(params: any): Promise<any>;
+}
+
+/**
+ * Common parameter schemas used across multiple ArgoCD commands
+ */
+export const ArgoCDCommonSchemas = {
+  namespace: {
+    type: 'string',
+    description: 'Kubernetes namespace (defaults to argocd namespace if not specified)',
+    optional: true,
+  },
+  appName: {
+    type: 'string',
+    description: 'Name of the ArgoCD application',
+  },
+  outputFormat: {
+    type: 'string',
+    description: 'Output format (json, yaml, name, wide)',
+    enum: ['json', 'yaml', 'name', 'wide'],
+    optional: true,
+  },
+  selector: {
+    type: 'string',
+    description: 'Selector (label query) to filter on',
+    optional: true,
+  },
+  server: {
+    type: 'string',
+    description: 'ArgoCD server address',
+    optional: true,
+  },
+  grpcWeb: {
+    type: 'boolean',
+    description: 'Use gRPC-Web protocol',
+    optional: true,
+  },
+  plaintext: {
+    type: 'boolean',
+    description: 'Use plaintext connection (no TLS)',
+    optional: true,
+  },
+  insecure: {
+    type: 'boolean',
+    description: 'Skip server certificate and domain verification',
+    optional: true,
+  },
+};
+
+/**
+ * Executes an argocd command using the argocd CLI
+ * @param args Array of command arguments
+ * @param argoCDExecutable Optional argocd executable path (for fallback scenarios)
+ * @returns Promise with the command output
+ */
+export async function executeArgoCDCommand(
+  args: string[],
+  argoCDExecutable = 'argocd',
+): Promise<any> {
+  return executeCliCommand('argocd', args, argoCDExecutable, 'ARGOCD_TIMEOUT');
+}
+
+/**
+ * Validates that argocd CLI is available with fallback detection
+ */
+export async function validateArgoCDCLI(): Promise<void> {
+  return validateCli('argocd', ['version', '--client'], 'ARGOCD_TIMEOUT');
+}

package/src/tools/argocd/index.ts

@@ -0,0 +1,7 @@
+export type { ArgoCDBaseTool } from './BaseTool.js';
+export { ArgoCDCommonSchemas, executeArgoCDCommand, validateArgoCDCLI } from './BaseTool.js';
+export { ArgoCDAppListTool } from './ArgoCDAppListTool.js';
+export { ArgoCDAppGetTool } from './ArgoCDAppGetTool.js';
+export { ArgoCDAppHistoryTool } from './ArgoCDAppHistoryTool.js';
+export { ArgoCDAppLogsTool } from './ArgoCDAppLogsTool.js';
+export { ArgoCDAppResourcesTool } from './ArgoCDAppResourcesTool.js';

package/src/tools/helm/BaseTool.ts

@@ -0,0 +1,60 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { executeCliCommand, validateCli } from '../../utils/CliUtils.js';
+
+/**
+ * Base interface for all Helm MCP tool commands
+ */
+export interface HelmBaseTool {
+  /**
+   * The tool definition for MCP registration
+   */
+  tool: Tool;
+
+  /**
+   * Execute the command with given parameters
+   */
+  execute(params: any): Promise<any>;
+}
+
+/**
+ * Common parameter schemas used across multiple Helm commands
+ */
+export const HelmCommonSchemas = {
+  namespace: {
+    type: 'string',
+    description: 'Kubernetes namespace (defaults to all namespaces if not specified)',
+    optional: true,
+  },
+  releaseName: {
+    type: 'string',
+    description: 'Name of the Helm release',
+  },
+  revision: {
+    type: 'number',
+    description: 'Revision number of the release',
+    optional: true,
+  },
+  outputFormat: {
+    type: 'string',
+    description: 'Output format (json, yaml, table)',
+    enum: ['json', 'yaml', 'table'],
+    optional: true,
+  },
+};
+
+/**
+ * Executes a helm command using the helm CLI
+ * @param args Array of command arguments
+ * @param helmExecutable Optional helm executable path (for fallback scenarios)
+ * @returns Promise with the command output
+ */
+export async function executeHelmCommand(args: string[], helmExecutable = 'helm'): Promise<any> {
+  return executeCliCommand('helm', args, helmExecutable, 'HELM_TIMEOUT');
+}
+
+/**
+ * Validates that helm CLI is available with fallback detection
+ */
+export async function validateHelmCLI(): Promise<void> {
+  return validateCli('helm', ['version', '--short'], 'HELM_TIMEOUT');
+}

package/src/tools/helm/HelmGetHooksTool.ts

@@ -0,0 +1,44 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { HelmBaseTool, HelmCommonSchemas, executeHelmCommand } from './BaseTool.js';
+
+/**
+ * Get hooks for a Helm release
+ */
+export class HelmGetHooksTool implements HelmBaseTool {
+  tool: Tool = {
+    name: 'helm_get_hooks',
+    description: 'Get the hooks for a named release (similar to `helm get hooks`)',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        releaseName: HelmCommonSchemas.releaseName,
+        namespace: HelmCommonSchemas.namespace,
+        revision: HelmCommonSchemas.revision,
+      },
+      required: ['releaseName'],
+    },
+  };
+
+  async execute(params: any): Promise<any> {
+    try {
+      const args = ['get', 'hooks', 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);
+      return result;
+    } catch (error: any) {
+      throw new Error(
+        `Failed to get hooks for Helm release '${params.releaseName}': ${error.message}`,
+      );
+    }
+  }
+}

package/src/tools/helm/HelmGetManifestTool.ts

@@ -0,0 +1,44 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { HelmBaseTool, HelmCommonSchemas, executeHelmCommand } from './BaseTool.js';
+
+/**
+ * Get manifest for a Helm release
+ */
+export class HelmGetManifestTool implements HelmBaseTool {
+  tool: Tool = {
+    name: 'helm_get_manifest',
+    description: 'Get the manifest for a named release (similar to `helm get manifest`)',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        releaseName: HelmCommonSchemas.releaseName,
+        namespace: HelmCommonSchemas.namespace,
+        revision: HelmCommonSchemas.revision,
+      },
+      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);
+      return result;
+    } catch (error: any) {
+      throw new Error(
+        `Failed to get manifest for Helm release '${params.releaseName}': ${error.message}`,
+      );
+    }
+  }
+}

package/src/tools/helm/HelmGetNotesTool.ts

@@ -0,0 +1,44 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { HelmBaseTool, HelmCommonSchemas, executeHelmCommand } from './BaseTool.js';
+
+/**
+ * Get notes for a Helm release
+ */
+export class HelmGetNotesTool implements HelmBaseTool {
+  tool: Tool = {
+    name: 'helm_get_notes',
+    description: 'Get the notes for a named release (similar to `helm get notes`)',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        releaseName: HelmCommonSchemas.releaseName,
+        namespace: HelmCommonSchemas.namespace,
+        revision: HelmCommonSchemas.revision,
+      },
+      required: ['releaseName'],
+    },
+  };
+
+  async execute(params: any): Promise<any> {
+    try {
+      const args = ['get', 'notes', 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);
+      return result;
+    } catch (error: any) {
+      throw new Error(
+        `Failed to get notes for Helm release '${params.releaseName}': ${error.message}`,
+      );
+    }
+  }
+}