kubeview-mcp 1.0.0

package/bin/kubeview-mcp.js

@@ -0,0 +1,274 @@
+#!/usr/bin/env node
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import { execSync, spawn } from 'child_process';
+import fs from 'fs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Colors for console output
+const colors = {
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+  reset: '\x1b[0m'
+};
+
+class KubeMCPCLI {
+  constructor() {
+    this.projectRoot = path.resolve(__dirname, '..');
+    this.setupScript = path.join(this.projectRoot, 'bin', 'setup.js');
+    this.cliScript = path.join(this.projectRoot, 'dist', 'src', 'cli', 'cli.js');
+  }
+
+  log(message, color = colors.reset) {
+    console.error(`${color}${message}${colors.reset}`);
+  }
+
+  error(message) {
+    console.error(`${colors.red}${message}${colors.reset}`);
+  }
+
+  info(message) {
+    this.log(message, colors.blue);
+  }
+
+  // Check if project is built and build if necessary
+  ensureBuild() {
+    const distDir = path.join(this.projectRoot, 'dist');
+    const indexPathFlat = path.join(distDir, 'index.js');
+    const indexPathNested = path.join(distDir, 'src', 'index.js');
+
+    // Check if project is built
+    if (!fs.existsSync(distDir) || (!fs.existsSync(indexPathFlat) && !fs.existsSync(indexPathNested))) {
+      this.log('🔧 Building kubeview-mcp...', colors.yellow);
+
+      try {
+        // Install dependencies if node_modules doesn't exist
+        const nodeModulesPath = path.join(this.projectRoot, 'node_modules');
+        if (!fs.existsSync(nodeModulesPath)) {
+          this.log('📦 Installing dependencies...', colors.blue);
+          execSync('npm install', { cwd: this.projectRoot, stdio: 'inherit' });
+        }
+
+        // Build the project
+        execSync('npm run build', { cwd: this.projectRoot, stdio: 'inherit' });
+        this.log('✅ Build completed successfully', colors.green);
+      } catch (buildError) {
+        this.error('❌ Build failed:');
+        console.error(buildError);
+        process.exit(1);
+      }
+    }
+  }
+
+  // Display help information
+  displayHelp() {
+    this.log('Kube MCP - Kubernetes MCP Server', colors.cyan);
+    console.log('\nA Kubernetes MCP server for Claude Desktop and Cursor IDE');
+    console.log('\nUsage:');
+    console.log('  kubeview-mcp <command> [options]');
+    console.log('');
+    console.log('Commands:');
+    console.log('  setup [target]     Setup configuration for Claude Desktop and/or Cursor IDE');
+    console.log('                     Targets: claude, cursor, both (default)');
+    console.log('  serve              Start the MCP server (default if no command specified)');
+    console.log('  build              Build the project');
+    console.log('  test               Run tests');
+    console.log('  lint               Run linter');
+    console.log('  help               Show this help message');
+    console.log('  version            Show version information');
+    console.log('');
+    console.log('Setup Examples:');
+    console.log('  kubeview-mcp setup           # Setup both Claude and Cursor');
+    console.log('  kubeview-mcp setup claude    # Setup Claude Desktop only');
+    console.log('  kubeview-mcp setup cursor    # Setup Cursor IDE only');
+    console.log('');
+    console.log('Server Examples:');
+    console.log('  kubeview-mcp                 # Start MCP server');
+    console.log('  kubeview-mcp serve           # Start MCP server explicitly');
+    console.log('');
+    console.log('Development Examples:');
+    console.log('  kubeview-mcp build           # Build the project');
+    console.log('  kubeview-mcp test            # Run tests');
+    console.log('  kubeview-mcp lint            # Run linter');
+    console.log('');
+    console.log('For more information, visit: https://github.com/your-org/kubeview-mcp');
+  }
+
+  // Display version information
+  displayVersion() {
+    try {
+      const packageJsonPath = path.join(this.projectRoot, 'package.json');
+      const packageContent = fs.readFileSync(packageJsonPath, 'utf8');
+      const packageJson = JSON.parse(packageContent);
+      this.log(`Kube MCP v${packageJson.version}`, colors.cyan);
+      console.log(`Description: ${packageJson.description}`);
+      console.log(`License: ${packageJson.license}`);
+      console.log(`Node.js: ${process.version}`);
+      console.log(`Platform: ${process.platform} ${process.arch}`);
+    } catch {
+      this.error('Could not read package.json');
+    }
+  }
+
+  // Run setup command
+  runSetup(target = 'both') {
+    this.info(`Running setup for: ${target}`);
+    try {
+      const setupProcess = spawn('node', [this.setupScript, target], {
+        stdio: 'inherit',
+        cwd: this.projectRoot
+      });
+
+      setupProcess.on('close', (code) => {
+        if (code === 0) {
+          this.log('\n✓ Setup completed successfully', colors.green);
+        } else {
+          this.error(`Setup failed with exit code ${code}`);
+          process.exit(code);
+        }
+      });
+
+      setupProcess.on('error', (error) => {
+        this.error(`Setup failed: ${error.message}`);
+        process.exit(1);
+      });
+    } catch (error) {
+      this.error(`Failed to run setup: ${error.message}`);
+      process.exit(1);
+    }
+  }
+
+  // Run MCP server using the built index.js file
+  async runServer(_args = []) {
+    this.ensureBuild();
+
+    const distDir = path.join(this.projectRoot, 'dist');
+    const indexPathFlat = path.join(distDir, 'index.js');
+    const indexPathNested = path.join(distDir, 'src', 'index.js');
+
+    try {
+      // Determine the correct index path after build
+      const finalIndexPath = fs.existsSync(indexPathFlat) ? indexPathFlat : indexPathNested;
+
+      // Debug: Check if the file actually exists
+      if (!fs.existsSync(finalIndexPath)) {
+        this.error(`❌ Built file not found at either location:`);
+        this.log(`   - Flat: ${indexPathFlat}`, colors.red);
+        this.log(`   - Nested: ${indexPathNested}`, colors.red);
+
+        // List what files do exist
+        const distContents = fs.existsSync(distDir) ? fs.readdirSync(distDir) : ['dist directory not found'];
+        this.log(`📂 Contents of dist/: ${distContents.join(', ')}`, colors.blue);
+
+        const srcDir = path.join(distDir, 'src');
+        if (fs.existsSync(srcDir)) {
+          const srcContents = fs.readdirSync(srcDir);
+          this.log(`📂 Contents of dist/src/: ${srcContents.join(', ')}`, colors.blue);
+        }
+
+        process.exit(1);
+      }
+
+      this.log(`🚀 Starting kubeview-mcp from: ${finalIndexPath}`, colors.green);
+      const { main } = await import(`file://${finalIndexPath}`);
+      await main();
+    } catch (runError) {
+      this.error('❌ Failed to start kubeview-mcp:');
+      console.error(runError);
+      process.exit(1);
+    }
+  }
+
+  // Run npm script
+  runNpmScript(script, args = []) {
+    this.info(`Running: npm run ${script}`);
+    try {
+      const command = args.length > 0 ? `npm run ${script} -- ${args.join(' ')}` : `npm run ${script}`;
+      execSync(command, {
+        cwd: this.projectRoot,
+        stdio: 'inherit'
+      });
+    } catch (error) {
+      this.error(`Failed to run npm script: ${script}`);
+      process.exit(error.status || 1);
+    }
+  }
+
+  // Main command router
+  async run() {
+    const args = process.argv.slice(2);
+
+    if (args.length === 0) {
+      // Default to running the server
+      await this.runServer();
+      return;
+    }
+
+    const command = args[0].toLowerCase();
+    const commandArgs = args.slice(1);
+
+    switch (command) {
+      case 'setup':
+        this.runSetup(commandArgs[0] || 'both');
+        break;
+
+      case 'serve':
+      case 'server':
+      case 'start':
+        await this.runServer(commandArgs);
+        break;
+
+      case 'build':
+        this.runNpmScript('build', commandArgs);
+        break;
+
+      case 'test':
+        this.runNpmScript('test', commandArgs);
+        break;
+
+      case 'lint':
+        this.runNpmScript('lint', commandArgs);
+        break;
+
+      case 'format':
+        this.runNpmScript('format', commandArgs);
+        break;
+
+      case 'typecheck':
+        this.runNpmScript('typecheck', commandArgs);
+        break;
+
+      case 'help':
+      case '--help':
+      case '-h':
+        this.displayHelp();
+        break;
+
+      case 'version':
+      case '--version':
+      case '-v':
+        this.displayVersion();
+        break;
+
+      default:
+        // For any other command, pass it directly to the MCP CLI
+        this.ensureBuild();
+        await this.runServer(args);
+        break;
+    }
+  }
+}
+
+// Run the CLI
+const cli = new KubeMCPCLI();
+cli.run().catch((err) => {
+  console.error(`${colors.red}❌ Unexpected error:${colors.reset}`);
+  console.error(err);
+  process.exit(1);
+});

package/bin/setup.js

@@ -0,0 +1,368 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import os from 'os';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Colors for console output
+const colors = {
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+  reset: '\x1b[0m'
+};
+
+class SetupManager {
+  constructor() {
+    this.projectRoot = path.resolve(__dirname, '..');
+    this.defaultKubeconfig = path.join(os.homedir(), '.kube', 'config');
+  }
+
+  log(message, color = colors.reset) {
+    console.log(`${color}${message}${colors.reset}`);
+  }
+
+  error(message, error = null) {
+    console.error(`${colors.red}${message}${colors.reset}`, error || '');
+  }
+
+  success(message) {
+    this.log(`✓ ${message}`, colors.green);
+  }
+
+  warning(message) {
+    this.log(`⚠️  ${message}`, colors.yellow);
+  }
+
+  info(message) {
+    this.log(message, colors.blue);
+  }
+
+  // Get platform-specific config path
+  getConfigPath(appName, configFileName) {
+    const platform = os.platform();
+    const home = os.homedir();
+
+    // Define platform-specific base paths
+    const platformPaths = {
+      'darwin': {
+        'Claude': path.join(home, 'Library', 'Application Support', 'Claude'),
+        'Cursor': path.join(home, '.cursor')
+      },
+      'win32': {
+        'Claude': path.join(home, 'AppData', 'Roaming', 'Claude'),
+        'Cursor': path.join(home, 'AppData', 'Roaming', 'Cursor')
+      },
+      'linux': {
+        'Claude': path.join(home, '.config', 'Claude'),
+        'Cursor': path.join(home, '.cursor')
+      }
+    };
+
+    if (!platformPaths[platform]) {
+      throw new Error(`Unsupported platform: ${platform}`);
+    }
+
+    if (!platformPaths[platform][appName]) {
+      throw new Error(`Unsupported app: ${appName} on platform: ${platform}`);
+    }
+
+    return path.join(platformPaths[platform][appName], configFileName);
+  }
+
+  // Get Claude Desktop config path
+  getClaudeConfigPath() {
+    return this.getConfigPath('Claude', 'claude_desktop_config.json');
+  }
+
+  // Get Cursor config path (global)
+  getCursorConfigPath() {
+    return this.getConfigPath('Cursor', 'mcp.json');
+  }
+
+  // Ensure directory exists
+  ensureDirectoryExists(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+      this.log(`Creating directory: ${dirPath}`, colors.yellow);
+      fs.mkdirSync(dirPath, { recursive: true });
+      return true;
+    }
+    return false;
+  }
+
+  // Load or create config file
+  loadConfig(configPath) {
+    const defaultConfig = { mcpServers: {} };
+
+    if (fs.existsSync(configPath)) {
+      this.log(`Found existing config at ${configPath}, updating...`, colors.yellow);
+      try {
+        const content = fs.readFileSync(configPath, 'utf8');
+        const config = JSON.parse(content);
+
+        // Ensure mcpServers exists
+        if (!config.mcpServers) {
+          config.mcpServers = {};
+        }
+
+        return config;
+      } catch (error) {
+        this.error(`Error reading existing config at ${configPath}:`, error);
+        process.exit(1);
+      }
+    } else {
+      this.log(`Creating new config at ${configPath}...`, colors.yellow);
+      return defaultConfig;
+    }
+  }
+
+  // Save config file
+  saveConfig(configPath, config, indent = 2) {
+    try {
+      fs.writeFileSync(configPath, JSON.stringify(config, null, indent));
+      this.success(`Successfully configured kubeview-mcp in ${configPath}`);
+      return true;
+    } catch (error) {
+      this.error(`Error writing config file ${configPath}:`, error);
+      return false;
+    }
+  }
+
+  // Check if kubeconfig exists
+  validateKubeconfig(kubeconfigPath) {
+    if (!fs.existsSync(kubeconfigPath)) {
+      this.warning(`Kubeconfig file not found at ${kubeconfigPath}`);
+      this.log('   Make sure your kubeconfig is properly configured.');
+      return false;
+    }
+    return true;
+  }
+
+  // Create MCP server configuration
+  createMcpServerConfig() {
+    return {
+      command: 'npx',
+      args: ['-y', 'https://github.com/mikhae1/kubeview-mcp'],
+      env: {
+        KUBECONFIG: process.env.KUBECONFIG || this.defaultKubeconfig
+      }
+    };
+  }
+
+  // Generic setup method for any IDE
+  setupIde(ideName, configPathGetter, jsonIndent = 2, showPlatformNotes = false) {
+    this.info(`Setting up ${ideName} configuration...`);
+
+    const configPath = configPathGetter.call(this);
+    const configDir = path.dirname(configPath);
+
+    this.log(`Platform detected: ${os.platform()}`, colors.yellow);
+    this.log(`${ideName} config path: ${configPath}`, colors.yellow);
+
+    // Ensure directory exists
+    this.ensureDirectoryExists(configDir);
+
+    // Load existing config or create new one
+    const config = this.loadConfig(configPath);
+
+    // Add or update kubeview-mcp configuration
+    config.mcpServers['kubeview-mcp'] = this.createMcpServerConfig();
+
+    // Save configuration
+    if (this.saveConfig(configPath, config, jsonIndent)) {
+      this.displayInfo(ideName, config);
+      if (showPlatformNotes) {
+        this.displayPlatformNotes(ideName);
+      }
+    }
+  }
+
+  // Setup Claude Desktop
+  setupClaude() {
+    this.setupIde('Claude Desktop', this.getClaudeConfigPath, 2, true);
+  }
+
+  // Setup Cursor IDE
+  setupCursor() {
+    this.setupIde('Cursor IDE global', this.getCursorConfigPath, 4, true);
+  }
+
+  // Generic display configuration info
+  displayInfo(ideName, config) {
+    const serverConfig = config.mcpServers['kubeview-mcp'];
+
+    console.log(`\n${ideName} Configuration:`);
+    console.log(`  Project root: ${this.projectRoot}`);
+    console.log(`  Entry point: ${serverConfig.args[0]}`);
+    console.log(`  Kubeconfig: ${serverConfig.env.KUBECONFIG}`);
+
+    if (serverConfig.env.LOG_LEVEL) {
+      console.log(`  Log level: ${serverConfig.env.LOG_LEVEL}`);
+    }
+
+    this.validateKubeconfig(serverConfig.env.KUBECONFIG);
+
+    const appName = ideName.split(' ')[0]; // Extract first word for app name
+    this.log(`\nNext steps for ${appName}:`, colors.yellow);
+    console.log('1. Build the project: npm run build');
+    console.log(`2. Restart ${ideName.includes('Desktop') ? 'Claude Desktop application' : 'Cursor IDE'}`);
+    console.log('3. Test with: "List all pods in the default namespace"');
+  }
+
+  // Legacy method for backward compatibility - now uses generic method
+  displayClaudeInfo(config) {
+    this.displayInfo('Claude Desktop', config);
+  }
+
+  // Legacy method for backward compatibility - now uses generic method
+  displayCursorInfo(config) {
+    this.displayInfo('Cursor IDE Global', config);
+  }
+
+  // Generic platform-specific notes display
+  displayPlatformNotes(ideName) {
+    const appName = ideName.split(' ')[0].toLowerCase(); // Extract first word and make lowercase
+    const title = appName === 'claude' ? 'Platform-specific notes:' : `Platform-specific notes for ${ideName}:`;
+
+    this.log(`\n${title}`, colors.blue);
+
+    const platform = os.platform();
+    const platformMessages = this.getPlatformMessages(appName, platform);
+
+    platformMessages.forEach(message => console.log(`• ${message}`));
+  }
+
+  // Get platform-specific messages for different apps
+  getPlatformMessages(appName, platform) {
+    const messages = {
+      claude: {
+        darwin: [
+          'On macOS, make sure Claude Desktop is downloaded from the official website',
+          'You may need to grant permissions for Claude to access your files'
+        ],
+        win32: [
+          'On Windows, ensure Claude Desktop has proper permissions',
+          'You may need to run as administrator for the first setup'
+        ],
+        linux: [
+          'On Linux, ensure the .config directory has proper permissions',
+          'Some distributions may require additional setup steps'
+        ]
+      },
+      cursor: {
+        darwin: [
+          'Global configuration stored in ~/.cursor/mcp.json',
+          'Make sure Cursor IDE has proper permissions to access your files',
+          'You may need to restart Cursor completely for changes to take effect'
+        ],
+        win32: [
+          'Global configuration stored in %APPDATA%/Cursor/mcp.json',
+          'Ensure Cursor IDE has proper permissions',
+          'You may need to run as administrator for the first setup'
+        ],
+        linux: [
+          'Global configuration stored in ~/.cursor/mcp.json',
+          'Ensure the .cursor directory has proper permissions',
+          'Some distributions may require additional setup steps'
+        ]
+      }
+    };
+
+    return messages[appName]?.[platform] || [`Generic setup notes for ${appName} on ${platform}`];
+  }
+
+  // Legacy method for backward compatibility
+  displayClaudePlatformNotes() {
+    this.displayPlatformNotes('Claude Desktop');
+  }
+
+  // Legacy method for backward compatibility
+  displayCursorPlatformNotes() {
+    this.displayPlatformNotes('Cursor IDE');
+  }
+
+  // Display usage help
+  displayHelp() {
+    this.log('Kube MCP Setup Tool', colors.blue);
+    console.log('\nUsage:');
+    console.log('  npm start setup [target]');
+    console.log('  node bin/setup.js [target]');
+    console.log('\nTargets:');
+    console.log('  claude   - Setup Claude Desktop configuration');
+    console.log('  cursor   - Setup Cursor IDE configuration');
+    console.log('  both     - Setup both Claude and Cursor (default)');
+    console.log('  help     - Show this help message');
+    console.log('\nExamples:');
+    console.log('  npm start setup claude');
+    console.log('  npm start setup cursor');
+    console.log('  npm start setup both');
+    console.log('  npm start setup');
+
+    console.log('\nZero-install via npx:\n');
+    console.log('npx https://github.com/mikhae1/kubeview-mcp\n');
+    console.log('Add the following to your mcp.json (e.g. ~/.cursor/mcp.json):\n');
+    console.log(`{
+  "mcpServers": {
+    "kubeview-mcp": {
+      "command": "npx",
+      "args": ["https://github.com/mikhae1/kubeview-mcp"],
+      "env": {
+        "KUBECONFIG": "$HOME/.kube/config"
+      }
+    }
+  }
+}`);
+  }
+
+  // Main setup method
+  run(target = 'both') {
+    this.log(`Kube MCP Setup Tool`, colors.cyan);
+    console.log();
+
+    switch (target.toLowerCase()) {
+      case 'claude':
+        this.setupClaude();
+        break;
+      case 'cursor':
+        this.setupCursor();
+        break;
+      case 'both':
+        this.setupClaude();
+        console.log('\n' + '='.repeat(50) + '\n');
+        this.setupCursor();
+        break;
+      case 'help':
+      case '--help':
+      case '-h':
+        this.displayHelp();
+        break;
+      default:
+        this.error(`Unknown target: ${target}`);
+        this.displayHelp();
+        process.exit(1);
+    }
+  }
+}
+
+// Parse command line arguments
+const args = process.argv.slice(2);
+let target = 'both';
+
+if (args.length > 0) {
+  // Handle both "setup claude" and just "claude" formats
+  if (args[0] === 'setup' && args[1]) {
+    target = args[1];
+  } else {
+    target = args[0];
+  }
+}
+
+// Run setup
+const setup = new SetupManager();
+setup.run(target);

package/dist/src/cli/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/src/cli/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../../src/cli/cli.ts"],"names":[],"mappings":""}

package/dist/src/cli/cli.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import { main } from '../index.js';
+function isMainModule() {
+    try {
+        // Check if this file is being executed directly
+        // This works for both direct execution and npx
+        const mainFile = process.argv[1];
+        return Boolean(mainFile &&
+            (mainFile.endsWith('cli.js') ||
+                mainFile.endsWith('cli.ts') ||
+                mainFile.includes('kubeview-mcp')));
+    }
+    catch {
+        return false;
+    }
+}
+if (isMainModule()) {
+    main().catch((error) => {
+        console.error('Unhandled error:', error);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=cli.js.map

package/dist/src/cli/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../../../src/cli/cli.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAEnC,SAAS,YAAY;IACnB,IAAI,CAAC;QACH,gDAAgD;QAChD,+CAA+C;QAC/C,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACjC,OAAO,OAAO,CACZ,QAAQ;YACN,CAAC,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC;gBAC1B,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC;gBAC3B,QAAQ,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC,CACvC,CAAC;IACJ,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED,IAAI,YAAY,EAAE,EAAE,CAAC;IACnB,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;QACrB,OAAO,CAAC,KAAK,CAAC,kBAAkB,EAAE,KAAK,CAAC,CAAC;QACzC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/src/index.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * Kubernetes MCP Server
+ * Main entry point for the Model Context Protocol server
+ */
+export declare const VERSION = "0.1.0";
+export declare function main(): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";AACA;;;GAGG;AAQH,eAAO,MAAM,OAAO,UAAU,CAAC;AAE/B,wBAAsB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CA+B1C"}