kubeview-mcp 1.0.0

package/src/tools/argo/ArgoListTool.ts

@@ -0,0 +1,143 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { ArgoBaseTool, ArgoCommonSchemas, executeArgoCommand } from './BaseTool.js';
+
+/**
+ * List Argo workflows
+ */
+export class ArgoListTool implements ArgoBaseTool {
+  tool: Tool = {
+    name: 'argo_list',
+    description: 'List Argo workflows in the cluster (similar to `argo list`)',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        namespace: ArgoCommonSchemas.namespace,
+        allNamespaces: ArgoCommonSchemas.allNamespaces,
+        outputFormat: {
+          type: 'string',
+          description: 'Output format for workflows. Supports: wide, name, json, yaml',
+          enum: ['wide', 'name', 'json', 'yaml'],
+          optional: true,
+          default: 'json',
+        },
+        selector: ArgoCommonSchemas.selector,
+        maxWorkflows: {
+          type: 'number',
+          description: 'Maximum number of workflows to return',
+          optional: true,
+        },
+        running: {
+          type: 'boolean',
+          description: 'Show running workflows only',
+          optional: true,
+        },
+        succeeded: {
+          type: 'boolean',
+          description: 'Show succeeded workflows only',
+          optional: true,
+        },
+        failed: {
+          type: 'boolean',
+          description: 'Show failed workflows only',
+          optional: true,
+        },
+        pending: {
+          type: 'boolean',
+          description: 'Show pending workflows only',
+          optional: true,
+        },
+        status: {
+          type: 'string',
+          description: 'Filter by workflow status (Running, Succeeded, Failed, Error, Pending)',
+          enum: ['Running', 'Succeeded', 'Failed', 'Error', 'Pending'],
+          optional: true,
+        },
+        completed: {
+          type: 'boolean',
+          description: 'Show completed workflows only',
+          optional: true,
+        },
+        since: {
+          type: 'string',
+          description: 'Show workflows newer than this duration (e.g., 1h, 30m)',
+          optional: true,
+        },
+        chunked: {
+          type: 'boolean',
+          description: 'Return large lists in chunks',
+          optional: true,
+        },
+      },
+      required: [],
+    },
+  };
+
+  async execute(params: any): Promise<any> {
+    const args = ['list'];
+
+    // Add namespace specification
+    if (params.allNamespaces) {
+      args.push('--all-namespaces');
+    } else if (params.namespace) {
+      args.push('-n', params.namespace);
+    }
+
+    // Add output format
+    if (params.outputFormat) {
+      args.push('-o', params.outputFormat);
+    } else {
+      args.push('-o', 'json');
+    }
+
+    // Add selector
+    if (params.selector) {
+      args.push('-l', params.selector);
+    }
+
+    // Add status filters
+    if (params.running) {
+      args.push('--running');
+    }
+    if (params.succeeded) {
+      args.push('--succeeded');
+    }
+    if (params.failed) {
+      args.push('--failed');
+    }
+    if (params.pending) {
+      args.push('--pending');
+    }
+    if (params.completed) {
+      args.push('--completed');
+    }
+
+    // Add status filter
+    if (params.status) {
+      args.push('--status', params.status);
+    }
+
+    // Add since filter
+    if (params.since) {
+      args.push('--since', params.since);
+    }
+
+    // Add chunked option
+    if (params.chunked) {
+      args.push('--chunk-size', '500');
+    }
+
+    // Add max workflows limit
+    if (params.maxWorkflows) {
+      args.push('--limit', params.maxWorkflows.toString());
+    }
+
+    try {
+      const result = await executeArgoCommand(args);
+      return result;
+    } catch (error) {
+      throw new Error(
+        `Failed to list Argo workflows: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+}

package/src/tools/argo/ArgoLogsTool.ts

@@ -0,0 +1,131 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { ArgoBaseTool, ArgoCommonSchemas, executeArgoCommand } from './BaseTool.js';
+
+/**
+ * Get logs from Argo workflows
+ */
+export class ArgoLogsTool implements ArgoBaseTool {
+  tool: Tool = {
+    name: 'argo_logs',
+    description: 'Get logs from Argo workflow pods (similar to `argo logs`)',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        workflowName: {
+          ...ArgoCommonSchemas.workflowName,
+          description: 'Name of the workflow to get logs from',
+        },
+        namespace: ArgoCommonSchemas.namespace,
+        container: {
+          type: 'string',
+          description: 'Container name to get logs from',
+          optional: true,
+        },
+        follow: {
+          type: 'boolean',
+          description: 'Follow the logs stream (note: this may timeout in MCP context)',
+          optional: true,
+        },
+        previous: {
+          type: 'boolean',
+          description: 'Get logs from previous container instance',
+          optional: true,
+        },
+        since: {
+          type: 'string',
+          description: 'Show logs newer than this duration (e.g., 1h, 30m)',
+          optional: true,
+        },
+        sinceTime: {
+          type: 'string',
+          description: 'Show logs after this 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 the log output',
+          optional: true,
+        },
+        grep: {
+          type: 'string',
+          description: 'Regular expression to filter log lines',
+          optional: true,
+        },
+        noColor: {
+          type: 'boolean',
+          description: 'Disable colored output',
+          optional: true,
+        },
+      },
+      required: ['workflowName'],
+    },
+  };
+
+  async execute(params: any): Promise<any> {
+    const args = ['logs', params.workflowName];
+
+    // Add namespace
+    if (params.namespace) {
+      args.push('-n', params.namespace);
+    }
+
+    // Add container specification
+    if (params.container) {
+      args.push('-c', params.container);
+    }
+
+    // Add follow option (with warning)
+    if (params.follow) {
+      args.push('-f');
+    }
+
+    // Add previous logs option
+    if (params.previous) {
+      args.push('--previous');
+    }
+
+    // Add since duration
+    if (params.since) {
+      args.push('--since', params.since);
+    }
+
+    // Add since time
+    if (params.sinceTime) {
+      args.push('--since-time', params.sinceTime);
+    }
+
+    // Add tail lines
+    if (params.tail) {
+      args.push('--tail', params.tail.toString());
+    }
+
+    // Add timestamps
+    if (params.timestamps) {
+      args.push('--timestamps');
+    }
+
+    // Add grep filter
+    if (params.grep) {
+      args.push('--grep', params.grep);
+    }
+
+    // Add no color option
+    if (params.noColor) {
+      args.push('--no-color');
+    }
+
+    try {
+      const result = await executeArgoCommand(args);
+      return result;
+    } catch (error) {
+      throw new Error(
+        `Failed to get Argo workflow logs: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+}

package/src/tools/argo/BaseTool.ts

@@ -0,0 +1,69 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { executeCliCommand, validateCli } from '../../utils/CliUtils.js';
+
+/**
+ * Base interface for all Argo MCP tool commands
+ */
+export interface ArgoBaseTool {
+  /**
+   * 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 Argo commands
+ */
+export const ArgoCommonSchemas = {
+  namespace: {
+    type: 'string',
+    description: 'Kubernetes namespace (defaults to argo namespace if not specified)',
+    optional: true,
+  },
+  workflowName: {
+    type: 'string',
+    description: 'Name of the Argo workflow',
+  },
+  cronWorkflowName: {
+    type: 'string',
+    description: 'Name of the Argo cron workflow',
+  },
+  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,
+  },
+  allNamespaces: {
+    type: 'boolean',
+    description: 'List workflows across all namespaces',
+    optional: true,
+  },
+};
+
+/**
+ * Executes an argo command using the argo CLI
+ * @param args Array of command arguments
+ * @param argoExecutable Optional argo executable path (for fallback scenarios)
+ * @returns Promise with the command output
+ */
+export async function executeArgoCommand(args: string[], argoExecutable = 'argo'): Promise<any> {
+  return executeCliCommand('argo', args, argoExecutable, 'ARGO_TIMEOUT');
+}
+
+/**
+ * Validates that argo CLI is available with fallback detection
+ */
+export async function validateArgoCLI(): Promise<void> {
+  return validateCli('argo', ['version'], 'ARGO_TIMEOUT');
+}

package/src/tools/argo/index.ts

@@ -0,0 +1,6 @@
+export type { ArgoBaseTool } from './BaseTool.js';
+export { ArgoCommonSchemas, executeArgoCommand, validateArgoCLI } from './BaseTool.js';
+export { ArgoListTool } from './ArgoListTool.js';
+export { ArgoLogsTool } from './ArgoLogsTool.js';
+export { ArgoCronListTool } from './ArgoCronListTool.js';
+export { ArgoGetTool } from './ArgoGetTool.js';

package/src/tools/argocd/ArgoCDAppGetTool.ts

@@ -0,0 +1,109 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { ArgoCDBaseTool, ArgoCDCommonSchemas, executeArgoCDCommand } from './BaseTool.js';
+
+/**
+ * Get details of an ArgoCD application
+ */
+export class ArgoCDAppGetTool implements ArgoCDBaseTool {
+  tool: Tool = {
+    name: 'argocd_app_get',
+    description: 'Get details of an ArgoCD application (similar to `argocd app get <app-name>`)',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        appName: {
+          ...ArgoCDCommonSchemas.appName,
+          optional: false,
+        },
+        outputFormat: {
+          type: 'string',
+          description: 'Output format for application details. Supports: json, yaml, wide',
+          enum: ['json', 'yaml', 'wide'],
+          optional: true,
+          default: 'json',
+        },
+        showOperation: {
+          type: 'boolean',
+          description: 'Show application operation',
+          optional: true,
+        },
+        showParams: {
+          type: 'boolean',
+          description: 'Show application parameters and overrides',
+          optional: true,
+        },
+        server: ArgoCDCommonSchemas.server,
+        grpcWeb: ArgoCDCommonSchemas.grpcWeb,
+        plaintext: ArgoCDCommonSchemas.plaintext,
+        insecure: ArgoCDCommonSchemas.insecure,
+        refresh: {
+          type: 'boolean',
+          description: 'Refresh application data when retrieving',
+          optional: true,
+        },
+        hardRefresh: {
+          type: 'boolean',
+          description: 'Refresh application data and ignore cache',
+          optional: true,
+        },
+      },
+      required: ['appName'],
+    },
+  };
+
+  async execute(params: any): Promise<any> {
+    const args = ['app', 'get', params.appName];
+
+    // Add output format
+    if (params.outputFormat) {
+      args.push('-o', params.outputFormat);
+    } else {
+      args.push('-o', 'json');
+    }
+
+    // Add show operation option
+    if (params.showOperation) {
+      args.push('--show-operation');
+    }
+
+    // Add show params option
+    if (params.showParams) {
+      args.push('--show-params');
+    }
+
+    // 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');
+    }
+
+    // Add refresh options
+    if (params.refresh) {
+      args.push('--refresh');
+    }
+
+    if (params.hardRefresh) {
+      args.push('--hard-refresh');
+    }
+
+    try {
+      const result = await executeArgoCDCommand(args);
+      return result;
+    } catch (error) {
+      throw new Error(
+        `Failed to get ArgoCD application "${params.appName}": ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+}

package/src/tools/argocd/ArgoCDAppHistoryTool.ts

@@ -0,0 +1,91 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { ArgoCDBaseTool, ArgoCDCommonSchemas, executeArgoCDCommand } from './BaseTool.js';
+
+/**
+ * Get history/revisions of an ArgoCD application
+ */
+export class ArgoCDAppHistoryTool implements ArgoCDBaseTool {
+  tool: Tool = {
+    name: 'argocd_app_history',
+    description:
+      'Get deployment history/revisions of an ArgoCD application (similar to `argocd app history <app-name>`)',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        appName: {
+          ...ArgoCDCommonSchemas.appName,
+          optional: false,
+        },
+        outputFormat: {
+          type: 'string',
+          description: 'Output format for application history. Supports: json, yaml, wide, id',
+          enum: ['json', 'yaml', 'wide', 'id'],
+          optional: true,
+          default: 'json',
+        },
+        revision: {
+          type: 'string',
+          description: 'Show details for a specific revision',
+          optional: true,
+        },
+        maxHistory: {
+          type: 'number',
+          description: 'Maximum number of history entries to return',
+          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', 'history', params.appName];
+
+    // Add output format
+    if (params.outputFormat) {
+      args.push('-o', params.outputFormat);
+    } else {
+      args.push('-o', 'json');
+    }
+
+    // Add specific revision
+    if (params.revision) {
+      args.push('--revision', params.revision);
+    }
+
+    // Add max history limit
+    if (params.maxHistory) {
+      args.push('--limit', params.maxHistory.toString());
+    }
+
+    // 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 history for "${params.appName}": ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+}

package/src/tools/argocd/ArgoCDAppListTool.ts

@@ -0,0 +1,144 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { ArgoCDBaseTool, ArgoCDCommonSchemas, executeArgoCDCommand } from './BaseTool.js';
+
+/**
+ * List ArgoCD applications
+ */
+export class ArgoCDAppListTool implements ArgoCDBaseTool {
+  tool: Tool = {
+    name: 'argocd_app_list',
+    description: 'List ArgoCD applications in the cluster (similar to `argocd app list`)',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        outputFormat: {
+          type: 'string',
+          description: 'Output format for applications. Supports: wide, name, json, yaml',
+          enum: ['wide', 'name', 'json', 'yaml'],
+          optional: true,
+          default: 'json',
+        },
+        selector: ArgoCDCommonSchemas.selector,
+        project: {
+          type: 'string',
+          description: 'Filter by project name',
+          optional: true,
+        },
+        cluster: {
+          type: 'string',
+          description: 'Filter by cluster name',
+          optional: true,
+        },
+        namespace: {
+          type: 'string',
+          description: 'Filter by target namespace',
+          optional: true,
+        },
+        repo: {
+          type: 'string',
+          description: 'Filter by repository URL',
+          optional: true,
+        },
+        health: {
+          type: 'string',
+          description: 'Filter by health status',
+          enum: ['Healthy', 'Progressing', 'Degraded', 'Suspended', 'Missing', 'Unknown'],
+          optional: true,
+        },
+        sync: {
+          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,
+        refresh: {
+          type: 'boolean',
+          description: 'Refresh application data when retrieving',
+          optional: true,
+        },
+      },
+      required: [],
+    },
+  };
+
+  async execute(params: any): Promise<any> {
+    const args = ['app', 'list'];
+
+    // Add output format
+    if (params.outputFormat) {
+      args.push('-o', params.outputFormat);
+    } else {
+      args.push('-o', 'json');
+    }
+
+    // Add selector
+    if (params.selector) {
+      args.push('-l', params.selector);
+    }
+
+    // Add project filter
+    if (params.project) {
+      args.push('--project', params.project);
+    }
+
+    // Add cluster filter
+    if (params.cluster) {
+      args.push('--cluster', params.cluster);
+    }
+
+    // Add namespace filter
+    if (params.namespace) {
+      args.push('--namespace', params.namespace);
+    }
+
+    // Add repository filter
+    if (params.repo) {
+      args.push('--repo', params.repo);
+    }
+
+    // Add health status filter
+    if (params.health) {
+      args.push('--health', params.health);
+    }
+
+    // Add sync status filter
+    if (params.sync) {
+      args.push('--sync', params.sync);
+    }
+
+    // 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');
+    }
+
+    // Add refresh option
+    if (params.refresh) {
+      args.push('--refresh');
+    }
+
+    try {
+      const result = await executeArgoCDCommand(args);
+      return result;
+    } catch (error) {
+      throw new Error(
+        `Failed to list ArgoCD applications: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+}