@rishibhushan/jenkins-mcp-server 1.0.0

package/bin/jenkins-mcp.js

@@ -0,0 +1,327 @@
+#!/usr/bin/env node
+/**
+ * Jenkins MCP Server - Node.js Wrapper
+ *
+ * This wrapper handles:
+ * - Python version detection (cross-platform)
+ * - Virtual environment creation
+ * - Dependency installation
+ * - Server execution
+ *
+ * Supports: Windows, macOS, Linux
+ */
+
+const { spawn, spawnSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+// Configuration
+const projectRoot = path.join(__dirname, '..');
+const args = process.argv.slice(2);
+const isWindows = process.platform === 'win32';
+
+// Color codes for terminal output (if supported)
+const colors = {
+  reset: '\x1b[0m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+  blue: '\x1b[34m'
+};
+
+function log(message, color = 'reset') {
+  const colorCode = process.stdout.isTTY ? colors[color] : '';
+  const resetCode = process.stdout.isTTY ? colors.reset : '';
+  console.log(`${colorCode}${message}${resetCode}`);
+}
+
+function error(message) {
+  console.error(`${colors.red}ERROR: ${message}${colors.reset}`);
+}
+
+/**
+ * Check for Python 3 installation
+ * @returns {string} Python command name
+ */
+function checkPython() {
+  const pythonCommands = isWindows
+    ? ['python', 'py', 'python3']
+    : ['python3', 'python'];
+
+  log('Checking for Python 3...', 'blue');
+
+  for (const cmd of pythonCommands) {
+    try {
+      const result = spawnSync(cmd, ['--version'], {
+        stdio: 'pipe',
+        encoding: 'utf-8'
+      });
+
+      if (result.status === 0) {
+        const output = result.stdout || result.stderr;
+        if (output.includes('Python 3')) {
+          const version = output.trim();
+          log(`✓ Found ${version}`, 'green');
+          return cmd;
+        }
+      }
+    } catch (e) {
+      // Command not found, try next
+      continue;
+    }
+  }
+
+  error('Python 3 is required but not found.');
+  console.error('\nPlease install Python 3.8 or higher from:');
+  console.error('  https://www.python.org/downloads/');
+  console.error('\nAfter installation, restart your terminal and try again.');
+  process.exit(1);
+}
+
+/**
+ * Get paths for virtual environment binaries
+ * @param {string} venvPath - Path to virtual environment
+ * @returns {Object} Paths to python and pip executables
+ */
+function getVenvPaths(venvPath) {
+  if (isWindows) {
+    return {
+      python: path.join(venvPath, 'Scripts', 'python.exe'),
+      pip: path.join(venvPath, 'Scripts', 'pip.exe')
+    };
+  } else {
+    return {
+      python: path.join(venvPath, 'bin', 'python'),
+      pip: path.join(venvPath, 'bin', 'pip')
+    };
+  }
+}
+
+/**
+ * Create virtual environment if it doesn't exist
+ * @param {string} pythonCmd - Python command to use
+ * @returns {string} Path to virtual environment
+ */
+function ensureVenv(pythonCmd) {
+  const venvPath = path.join(projectRoot, '.venv');
+
+  if (fs.existsSync(venvPath)) {
+    log('✓ Virtual environment exists', 'green');
+    return venvPath;
+  }
+
+  log('Creating Python virtual environment...', 'yellow');
+
+  const result = spawnSync(pythonCmd, ['-m', 'venv', venvPath], {
+    cwd: projectRoot,
+    stdio: 'inherit'
+  });
+
+  if (result.status !== 0) {
+    error('Failed to create virtual environment');
+    console.error('\nTroubleshooting:');
+    console.error('  1. Ensure Python venv module is installed');
+    console.error('  2. Check disk space and permissions');
+    console.error('  3. Try manually: python3 -m venv .venv');
+    process.exit(1);
+  }
+
+  log('✓ Virtual environment created', 'green');
+  return venvPath;
+}
+
+/**
+ * Check if dependencies are installed
+ * @param {string} pipPath - Path to pip executable
+ * @returns {boolean} True if dependencies are installed
+ */
+function dependenciesInstalled(pipPath) {
+  try {
+    const result = spawnSync(pipPath, ['list'], {
+      stdio: 'pipe',
+      encoding: 'utf-8'
+    });
+
+    if (result.status === 0) {
+      const output = result.stdout || '';
+      // Check for key dependencies
+      return output.includes('python-jenkins') &&
+             output.includes('mcp') &&
+             output.includes('requests');
+    }
+  } catch (e) {
+    // If we can't check, assume not installed
+  }
+  return false;
+}
+
+/**
+ * Install Python dependencies
+ * @param {string} venvPath - Path to virtual environment
+ */
+function installDependencies(venvPath) {
+  const { pip } = getVenvPaths(venvPath);
+  const requirementsPath = path.join(projectRoot, 'requirements.txt');
+
+  if (!fs.existsSync(requirementsPath)) {
+    error('requirements.txt not found');
+    console.error(`Expected at: ${requirementsPath}`);
+    process.exit(1);
+  }
+
+  log('Installing Python dependencies...', 'yellow');
+  log('This may take a minute...', 'blue');
+
+  const result = spawnSync(pip, ['install', '-r', requirementsPath], {
+    cwd: projectRoot,
+    stdio: 'inherit'
+  });
+
+  if (result.status !== 0) {
+    error('Failed to install dependencies');
+    console.error('\nTroubleshooting:');
+    console.error('  1. Check your internet connection');
+    console.error('  2. If behind a proxy, set HTTP_PROXY/HTTPS_PROXY env vars');
+    console.error('  3. Try manually: .venv/bin/pip install -r requirements.txt');
+    process.exit(1);
+  }
+
+  log('✓ Dependencies installed', 'green');
+}
+
+/**
+ * Find the Python entry point
+ * @returns {Object} Entry point information
+ */
+function findEntryPoint() {
+  const mainPyPath = path.join(projectRoot, 'src', 'jenkins_mcp_server', '__main__.py');
+
+  if (fs.existsSync(mainPyPath)) {
+    return {
+      type: 'module',
+      args: ['-m', 'jenkins_mcp_server']
+    };
+  }
+
+  // Fallback options
+  const fallbacks = [
+    path.join(projectRoot, 'src', 'jenkins_mcp_server', 'server.py'),
+    path.join(projectRoot, 'src', 'main.py'),
+    path.join(projectRoot, 'main.py')
+  ];
+
+  for (const filePath of fallbacks) {
+    if (fs.existsSync(filePath)) {
+      return {
+        type: 'script',
+        args: [filePath]
+      };
+    }
+  }
+
+  error('Could not find Python entry point');
+  console.error('\nExpected one of:');
+  console.error('  - src/jenkins_mcp_server/__main__.py (preferred)');
+  console.error('  - src/jenkins_mcp_server/server.py');
+  console.error('  - src/main.py');
+  process.exit(1);
+}
+
+/**
+ * Run the Jenkins MCP Server
+ * @param {string} venvPath - Path to virtual environment
+ */
+function runServer(venvPath) {
+  const { python } = getVenvPaths(venvPath);
+  const entryPoint = findEntryPoint();
+
+  // Set up environment
+  const env = {
+    ...process.env,
+    PYTHONPATH: path.join(projectRoot, 'src'),
+    PYTHONUNBUFFERED: '1'  // Ensure output is not buffered
+  };
+
+  const serverArgs = [...entryPoint.args, ...args];
+
+  log('Starting Jenkins MCP Server...', 'green');
+  log(`Command: ${python} ${serverArgs.join(' ')}`, 'blue');
+
+  const server = spawn(python, serverArgs, {
+    cwd: projectRoot,
+    stdio: 'inherit',
+    env: env,
+    shell: isWindows
+  });
+
+  server.on('error', (err) => {
+    error(`Failed to start server: ${err.message}`);
+    process.exit(1);
+  });
+
+  server.on('close', (code) => {
+    if (code !== 0 && code !== null) {
+      log(`Server exited with code ${code}`, 'yellow');
+    }
+    process.exit(code || 0);
+  });
+
+  // Handle graceful shutdown
+  const cleanup = () => {
+    log('\nShutting down...', 'yellow');
+    server.kill('SIGTERM');
+  };
+
+  process.on('SIGINT', cleanup);
+  process.on('SIGTERM', cleanup);
+
+  // Windows doesn't support SIGINT/SIGTERM the same way
+  if (isWindows) {
+    process.on('SIGBREAK', cleanup);
+  }
+}
+
+/**
+ * Main execution flow
+ */
+function main() {
+  try {
+    // Check for help flag
+    if (args.includes('--help') || args.includes('-h')) {
+      console.log('Jenkins MCP Server - Node.js Wrapper');
+      console.log('\nUsage: jenkins-mcp-server [options]');
+      console.log('\nOptions:');
+      console.log('  --env-file PATH    Path to custom .env file');
+      console.log('  --verbose, -v      Enable verbose logging');
+      console.log('  --no-vscode        Skip loading VS Code settings');
+      console.log('  --version          Show version');
+      console.log('  --help, -h         Show this help message');
+      process.exit(0);
+    }
+
+    // Check Python availability
+    const pythonCmd = checkPython();
+
+    // Ensure virtual environment exists
+    const venvPath = ensureVenv(pythonCmd);
+
+    // Check and install dependencies if needed
+    const { pip } = getVenvPaths(venvPath);
+    if (!dependenciesInstalled(pip)) {
+      installDependencies(venvPath);
+    } else {
+      log('✓ Dependencies already installed', 'green');
+    }
+
+    // Run the server
+    runServer(venvPath);
+
+  } catch (err) {
+    error(`Unexpected error: ${err.message}`);
+    console.error(err.stack);
+    process.exit(1);
+  }
+}
+
+// Run main function
+main();

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@rishibhushan/jenkins-mcp-server",
+  "version": "1.0.0",
+  "description": "AI-enabled Jenkins automation via Model Context Protocol (MCP)",
+  "main": "bin/jenkins-mcp.js",
+  "bin": {
+    "jenkins-mcp-server": "bin/jenkins-mcp.js"
+  },
+  "scripts": {
+    "start": "node bin/jenkins-mcp.js",
+    "test": "python -m pytest tests/",
+    "build": "python -m build"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "requirements.txt",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "keywords": [
+    "mcp",
+    "jenkins",
+    "ai",
+    "automation",
+    "ci-cd",
+    "devops",
+    "model-context-protocol",
+    "llm",
+    "chatgpt",
+    "claude"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rishibhushan/jenkins_mcp_server.git"
+  },
+  "bugs": {
+    "url": "https://github.com/rishibhushan/jenkins_mcp_server/issues"
+  },
+  "homepage": "https://github.com/rishibhushan/jenkins_mcp_server#readme",
+  "author": "Rishi Bhushan",
+  "license": "MIT",
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ]
+}

package/requirements.txt

@@ -0,0 +1,12 @@
+# Core dependencies
+mcp>=1.0.0
+python-jenkins>=1.8.0
+requests>=2.28.0
+
+# Settings management
+pydantic>=2.0.0
+pydantic-settings>=2.0.0
+python-dotenv>=1.0.0
+
+# HTTP improvements
+urllib3>=2.0.0

package/src/jenkins_mcp_server/__init__.py

@@ -0,0 +1,133 @@
+"""
+Jenkins MCP Server Package
+
+Main entry point for the Jenkins MCP Server.
+"""
+
+import argparse
+import asyncio
+import logging
+import sys
+
+from .config import get_settings, get_default_settings
+from . import server
+
+
+def setup_logging(verbose: bool = False) -> None:
+    """Configure logging for the application"""
+    level = logging.DEBUG if verbose else logging.INFO
+
+    logging.basicConfig(
+        level=level,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        stream=sys.stderr
+    )
+
+    # Reduce noise from libraries
+    logging.getLogger('urllib3').setLevel(logging.WARNING)
+    logging.getLogger('requests').setLevel(logging.WARNING)
+
+
+def main():
+    """
+    Main entry point for the Jenkins MCP Server.
+
+    Parses command-line arguments, configures settings, and starts the server.
+    """
+    parser = argparse.ArgumentParser(
+        description='Jenkins MCP Server - AI-enabled Jenkins automation',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  %(prog)s                                    # Use default .env file
+  %(prog)s --env-file /path/to/.env           # Use custom .env file
+  %(prog)s --verbose                          # Enable debug logging
+  %(prog)s --env-file custom.env --verbose    # Combined options
+
+Environment Variables:
+  JENKINS_URL         Jenkins server URL (e.g., http://localhost:8080)
+  JENKINS_USERNAME    Jenkins username
+  JENKINS_TOKEN       Jenkins API token (recommended)
+  JENKINS_PASSWORD    Jenkins password (alternative to token)
+
+Configuration Priority:
+  1. Command-line arguments (--env-file)
+  2. VS Code settings.json
+  3. Environment variables
+  4. Default .env file
+        """
+    )
+
+    parser.add_argument(
+        '--env-file',
+        metavar='PATH',
+        help='Path to custom .env file with Jenkins credentials'
+    )
+
+    parser.add_argument(
+        '--verbose', '-v',
+        action='store_true',
+        help='Enable verbose/debug logging'
+    )
+
+    parser.add_argument(
+        '--version',
+        action='version',
+        version='jenkins-mcp-server 1.0.0'
+    )
+
+    parser.add_argument(
+        '--no-vscode',
+        action='store_true',
+        help='Skip loading settings from VS Code (use only .env/environment)'
+    )
+
+    args = parser.parse_args()
+
+    # Setup logging first
+    setup_logging(args.verbose)
+    logger = logging.getLogger(__name__)
+
+    try:
+        # Load settings based on arguments
+        logger.info("Loading Jenkins configuration...")
+
+        settings = get_settings(
+            env_file=args.env_file,
+            load_vscode=not args.no_vscode
+        )
+
+        # Validate configuration
+        if not settings.is_configured:
+            logger.error("Jenkins configuration is incomplete!")
+            logger.error("Required: URL, username, and (token or password)")
+            logger.error("\nPlease configure via:")
+            logger.error("  1. .env file (JENKINS_URL, JENKINS_USERNAME, JENKINS_TOKEN)")
+            logger.error("  2. VS Code settings.json")
+            logger.error("  3. Environment variables")
+            logger.error("\nFor help, run: %(prog)s --help" % {'prog': parser.prog})
+            sys.exit(1)
+
+        # Log configuration summary
+        logger.info(f"Jenkins server: {settings.url}")
+        logger.info(f"Username: {settings.username}")
+        logger.info(f"Authentication: {settings.auth_method}")
+
+        # Pass settings to server module
+        server.set_jenkins_settings(settings)
+
+        # Run the server
+        logger.info("Starting Jenkins MCP Server...")
+        asyncio.run(server.main())
+
+    except KeyboardInterrupt:
+        logger.info("Server stopped by user")
+        sys.exit(0)
+    except Exception as e:
+        logger.error(f"Failed to start server: {e}", exc_info=args.verbose)
+        sys.exit(1)
+
+
+# Package metadata
+__version__ = "1.0.0"
+__all__ = ['main', 'server']

package/src/jenkins_mcp_server/__main__.py

@@ -0,0 +1,19 @@
+#!/usr/bin/env python3
+"""
+Main entry point for running the Jenkins MCP Server as a module.
+
+Usage:
+    python -m jenkins_mcp_server [options]
+    
+Options:
+    --env-file PATH    Path to custom .env file
+    --verbose, -v      Enable verbose logging
+    --no-vscode        Skip loading VS Code settings
+    --version          Show version and exit
+    --help, -h         Show help message
+"""
+
+from . import main
+
+if __name__ == "__main__":
+    main()