@rishibhushan/jenkins-mcp-server 1.0.2 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rishibhushan/jenkins-mcp-server",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "AI-enabled Jenkins automation via Model Context Protocol (MCP)",
   "main": "bin/jenkins-mcp.js",
   "bin": {

package/src/jenkins_mcp_server/__init__.py

@@ -34,6 +34,8 @@ def main():
 
     Parses command-line arguments, configures settings, and starts the server.
     """
+
+    print("=== Jenkins MCP Server: Entry point called ===", file=sys.stderr, flush=True)
     parser = argparse.ArgumentParser(
         description='Jenkins MCP Server - AI-enabled Jenkins automation',
         formatter_class=argparse.RawDescriptionHelpFormatter,
@@ -82,20 +84,26 @@ Configuration Priority:
         help='Skip loading settings from VS Code (use only .env/environment)'
     )
 
+    print("=== Parsing arguments ===", file=sys.stderr, flush=True)
     args = parser.parse_args()
+    print(f"=== Args parsed: env_file={args.env_file}, verbose={args.verbose} ===", file=sys.stderr, flush=True)
 
     # Setup logging first
+    print("=== Setting up logging ===", file=sys.stderr, flush=True)
     setup_logging(args.verbose)
     logger = logging.getLogger(__name__)
+    print("=== Logging configured ===", file=sys.stderr, flush=True)
 
     try:
         # Load settings based on arguments
+        print("=== Loading Jenkins configuration ===", file=sys.stderr, flush=True)
         logger.info("Loading Jenkins configuration...")
 
         settings = get_settings(
             env_file=args.env_file,
             load_vscode=not args.no_vscode
         )
+        print(f"=== Settings loaded: url={settings.url}, configured={settings.is_configured} ===", file=sys.stderr, flush=True)
 
         # Validate configuration
         if not settings.is_configured:
@@ -109,22 +117,30 @@ Configuration Priority:
             sys.exit(1)
 
         # Log configuration summary
+        print("=== Configuration validated ===", file=sys.stderr, flush=True)
         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
+        print("=== Setting server settings ===", file=sys.stderr, flush=True)
         server.set_jenkins_settings(settings)
+        print("=== Server settings configured ===", file=sys.stderr, flush=True)
 
         # Run the server
+        print("=== Starting asyncio server ===", file=sys.stderr, flush=True)
         logger.info("Starting Jenkins MCP Server...")
         asyncio.run(server.main())
 
     except KeyboardInterrupt:
+        print("=== Server stopped by user ===", file=sys.stderr, flush=True)
         logger.info("Server stopped by user")
         sys.exit(0)
     except Exception as e:
+        print(f"=== EXCEPTION: {e} ===", file=sys.stderr, flush=True)
         logger.error(f"Failed to start server: {e}", exc_info=args.verbose)
+        import traceback
+        traceback.print_exc(file=sys.stderr)
         sys.exit(1)
 
 

package/src/jenkins_mcp_server/config.py

@@ -223,15 +223,25 @@ def load_settings(
     Returns:
         JenkinsSettings instance with merged configuration
     """
+    import sys
+    print(f"=== config.load_settings called: env_file={env_file}, load_vscode={load_vscode} ===", file=sys.stderr,
+          flush=True)
+
     # Start with environment variables and .env file
     if env_file:
+        print(f"=== Using custom env file: {env_file} ===", file=sys.stderr, flush=True)
         settings = JenkinsSettings(_env_file=env_file)
     else:
+        print("=== Using default .env ===", file=sys.stderr, flush=True)
         settings = JenkinsSettings()
 
+    print(f"=== Initial settings: url={settings.url} ===", file=sys.stderr, flush=True)
+
     # Override with VS Code settings if requested
     if load_vscode:
+        print("=== Loading VS Code settings ===", file=sys.stderr, flush=True)
         vscode_settings = VSCodeSettingsLoader.load()
+        print(f"=== VS Code settings loaded: {vscode_settings is not None} ===", file=sys.stderr, flush=True)
         if vscode_settings:
             # Merge VS Code settings into our settings object
             for key in ['url', 'username', 'password', 'token']:
@@ -240,11 +250,14 @@ def load_settings(
                     setattr(settings, key, vscode_value)
 
     # Apply direct overrides (highest priority)
+    print("=== Applying overrides ===", file=sys.stderr, flush=True)
     for key, value in override_values.items():
         if value is not None and hasattr(settings, key):
             setattr(settings, key, value)
 
     # Log final configuration
+    print(f"=== Final settings: url={settings.url}, configured={settings.is_configured} ===", file=sys.stderr,
+          flush=True)
     settings.log_config()
 
     return settings
@@ -275,4 +288,4 @@ def get_default_settings() -> JenkinsSettings:
     global _default_settings
     if _default_settings is None:
         _default_settings = load_settings()
-    return _default_settings
+    return _default_settings

package/src/jenkins_mcp_server.egg-info/PKG-INFO

@@ -0,0 +1,624 @@
+Metadata-Version: 2.4
+Name: jenkins-mcp-server
+Version: 1.0.0
+Summary: AI-enabled Jenkins automation via Model Context Protocol (MCP)
+Author-email: Rishi Bhushan <rishibharat2007@gmail.com>
+Maintainer-email: Rishi Bhushan <rishibharat2007@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/rishibhushan/jenkins_mcp_server
+Project-URL: Documentation, https://github.com/rishibhushan/jenkins_mcp_server#readme
+Project-URL: Repository, https://github.com/rishibhushan/jenkins_mcp_server.git
+Project-URL: Bug Tracker, https://github.com/rishibhushan/jenkins_mcp_server/issues
+Project-URL: Changelog, https://github.com/rishibhushan/jenkins_mcp_server/releases
+Keywords: mcp,jenkins,ai,automation,ci-cd,devops,model-context-protocol,llm
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: System :: Systems Administration
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: python-jenkins>=1.8.0
+Requires-Dist: requests>=2.28.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pydantic-settings>=2.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: urllib3>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Provides-Extra: test
+Requires-Dist: pytest>=7.0.0; extra == "test"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "test"
+Requires-Dist: pytest-cov>=4.0.0; extra == "test"
+
+# 🧠 Jenkins MCP Server
+
+**Jenkins MCP Server** is an AI-enabled Model Context Protocol (MCP) server that exposes Jenkins automation through natural-language commands.
+
+Designed to work seamlessly with automation clients such as:
+- 🖥️ **VS Code MCP** - Direct integration with Claude in VS Code
+- 🔌 **Any MCP-compatible client** - Universal compatibility
+
+## ✨ About codebase
+
+- ✅ **Codebase** - cleaner, more maintainable
+- ✅ **Error messages** - Know exactly what's wrong and how to fix it
+- ✅ **Flexible configuration** - Multiple ways to configure (VS Code, .env, environment)
+- ✅ **Cross-platform** - Seamless support for Windows, macOS, and Linux
+- ✅ **Logging** - Professional logging with `--verbose` flag
+- ✅ **Dependency management** - Automatic detection and installation
+
+---
+
+## 📦 Features
+
+This project includes:
+- 🐍 Python backend powered by `python-jenkins`
+- 📦 Node.js `npx` wrapper for zero-install execution
+- 🔄 Automatic virtual environment creation + dependency installation
+- 🌐 Corporate proxy/certificate auto-detection support
+- 🪟 Windows, macOS, and Linux support
+- 🛠️ **20 Jenkins management tools**
+
+### 🧩 Build Operations
+| Tool Name | Description | Required Fields | Optional Fields |
+|---|---|---|---|
+| `trigger-build` | Trigger a Jenkins job build with optional parameters | `job_name` | `parameters` |
+| `stop-build` | Stop a running Jenkins build | `job_name`, `build_number` | *(none)* |
+
+### 📊 Job Information
+| Tool Name | Description | Required Fields | Optional Fields |
+|---|---|---|---|
+| `list-jobs` | List all Jenkins jobs with optional filtering | *(none)* | `filter` |
+| `get-job-details` | Get detailed information about a Jenkins job | `job_name` | *(none)* |
+
+### 🛠️ Build Information
+| Tool Name | Description | Required Fields | Optional Fields |
+|---|---|---|---|
+| `get-build-info` | Get information about a specific build | `job_name`, `build_number` | *(none)* |
+| `get-build-console` | Get console output from a build | `job_name`, `build_number` | *(none)* |
+| `get-last-build-number` | Get the last build number for a job | `job_name` | *(none)* |
+| `get-last-build-timestamp` | Get the timestamp of the last build | `job_name` | *(none)* |
+
+### 🧩 Job Management
+| Tool Name | Description | Required Fields | Optional Fields |
+|---|---|---|---|
+| `create-job` | Create a new Jenkins job with XML configuration | `job_name`, `config_xml` | *(none)* |
+| `create-job-from-copy` | Create a new job by copying an existing one | `new_job_name`, `source_job_name` | *(none)* |
+| `create-job-from-data` | Create a job from structured data (auto-generated XML) | `job_name`, `config_data` | `root_tag` |
+| `delete-job` | Delete an existing job | `job_name` | *(none)* |
+| `enable-job` | Enable a disabled Jenkins job | `job_name` | *(none)* |
+| `disable-job` | Disable a Jenkins job | `job_name` | *(none)* |
+| `rename-job` | Rename an existing Jenkins job | `job_name`, `new_name` | *(none)* |
+
+### ⚙️ Job Configuration
+| Tool Name | Description | Required Fields | Optional Fields |
+|---|---|---|---|
+| `get-job-config` | Fetch job XML configuration | `job_name` | *(none)* |
+| `update-job-config` | Update job XML configuration | `job_name`, `config_xml` | *(none)* |
+
+### 🖥️ System Information
+| Tool Name | Description | Required Fields | Optional Fields |
+|---|---|---|---|
+| `get-queue-info` | Get Jenkins build queue info | *(none)* | *(none)* |
+| `list-nodes` | List all Jenkins nodes | *(none)* | *(none)* |
+| `get-node-info` | Get information about a Jenkins node | `node_name` | *(none)* |
+
+---
+
+## 🚀 Quick Start
+
+### Prerequisites
+
+**Node.js** (v14 or higher) is required for the npx wrapper.
+
+<details>
+<summary><b>Windows Installation</b></summary>
+
+```powershell
+# Using winget (recommended)
+winget install OpenJS.NodeJS.LTS
+
+# Verify installation
+node -v
+npm -v
+```
+
+Or download manually from https://nodejs.org/
+</details>
+
+<details>
+<summary><b>macOS Installation</b></summary>
+
+```bash
+# Install nvm (Node Version Manager)
+curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
+
+# Reload shell
+source ~/.nvm/nvm.sh
+
+# Install Node LTS
+nvm install --lts
+nvm use --lts
+
+# Verify installation
+node -v
+npm -v
+```
+</details>
+
+<details>
+<summary><b>Linux Installation</b></summary>
+
+```bash
+# Ubuntu/Debian
+curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash -
+sudo apt-get install -y nodejs
+
+# Fedora/RHEL
+curl -fsSL https://rpm.nodesource.com/setup_lts.x | sudo bash -
+sudo dnf install -y nodejs
+
+# Verify installation
+node -v
+npm -v
+```
+</details>
+
+---
+
+## ⚙️ Configuration
+
+Jenkins MCP Server supports multiple configuration methods. Choose the one that works best for you:
+
+### Option 1: VS Code Settings (Recommended)
+
+Add to your VS Code `settings.json`:
+
+```json
+{
+  "jenkins-mcp-server": {
+    "jenkins": {
+      "url": "http://jenkins.example.com:8080",
+      "username": "your-username",
+      "token": "your-api-token"
+    }
+  }
+}
+```
+
+**Where to find settings.json:**
+- **Windows**: `%APPDATA%\Code\User\settings.json`
+- **macOS**: `~/Library/Application Support/Code/User/settings.json`
+- **Linux**: `~/.config/Code/User/settings.json`
+
+### Option 2: Environment File (.env)
+
+Rename `.env.template` to `.env`
+```bash
+cp .env.template .env
+```
+
+In the `.env` file in your project directory:
+
+```bash
+JENKINS_URL=http://jenkins.example.com:8080
+JENKINS_USERNAME=your-username
+JENKINS_TOKEN=your-api-token
+```
+
+**Note**: Use API token instead of password for better security.
+
+### Option 3: Environment Variables
+
+```bash
+# Linux/macOS
+export JENKINS_URL=http://jenkins.example.com:8080
+export JENKINS_USERNAME=your-username
+export JENKINS_TOKEN=your-api-token
+
+# Windows (PowerShell)
+$env:JENKINS_URL="http://jenkins.example.com:8080"
+$env:JENKINS_USERNAME="your-username"
+$env:JENKINS_TOKEN="your-api-token"
+```
+
+### Configuration Priority
+
+Settings are loaded in this order (later overrides earlier):
+1. Default `.env` file
+2. Environment variables
+3. Custom `.env` file (via `--env-file`)
+4. VS Code settings
+5. Direct parameters
+
+### Getting Your Jenkins API Token
+
+1. Log into Jenkins
+2. Click your name (top right) → **Configure**
+3. Scroll to **API Token** section
+4. Click **Add new Token**
+5. Give it a name and click **Generate**
+6. Copy the token (⚠️ it won't be shown again!)
+
+---
+
+## 🚀 Installation/Running the Server
+
+### Option 1: Using npx (No Installation Required)
+```bash
+npx @rishibhushan/jenkins-mcp-server --env-file .env
+```
+
+### Option 2: Global Installation
+```bash
+# Install globally
+npm install -g @rishibhushan/jenkins-mcp-server
+
+# Run
+jenkins-mcp-server --env-file .env
+```
+
+### Option 3: From GitHub
+```bash
+npx github:rishibhushan/jenkins_mcp_server --env-file .env
+```
+
+[//]: # ([![npm version]&#40;https://badge.fury.io/js/jenkins-mcp-server.svg&#41;]&#40;https://www.npmjs.com/package/@rishibhushan/jenkins-mcp-server&#41;)
+
+[//]: # ([![npm downloads]&#40;https://img.shields.io/npm/dm/jenkins-mcp-server.svg&#41;]&#40;https://www.npmjs.com/package/@rishibhushan/jenkins-mcp-server&#41;)
+
+---
+
+This automatically:
+- ✅ Installs all dependencies
+- ✅ Starts the Jenkins MCP server
+
+### Method 2: Direct Python Execution
+
+```bash
+# Create virtual environment
+python3 -m venv .venv
+
+# Activate virtual environment
+# Linux/macOS:
+source .venv/bin/activate
+# Windows:
+.venv\Scripts\activate
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Run the server
+python -m jenkins_mcp_server --env-file /path/to/.env
+```
+
+### Command-Line Options
+
+```
+jenkins-mcp-server [options]
+
+Options:
+  --env-file PATH    Path to custom .env file
+  --verbose, -v      Enable verbose/debug logging
+  --no-vscode        Skip loading VS Code settings
+  --version          Show version information
+  --help, -h         Show help message
+```
+
+---
+
+## 🔌 Integration Examples
+
+### VS Code MCP Client
+
+Add to your VS Code `mcp.json`:
+
+```json
+{
+  "servers": {
+    "jenkins": {
+      "type": "stdio",
+      "command": "npx",
+      "args": [
+        "@rishibhushan/jenkins-mcp-server"
+      ]
+    }
+  }
+}
+```
+
+Or `setting.json` with `.env` file and proxy settings:
+```json
+{
+  "mcp": {
+    "servers": {
+      "jenkins": {
+        "type": "stdio",
+        "command": "npx",
+        "args": [
+          "@rishibhushan/jenkins-mcp-server",
+          "--verbose",
+          "--env-file",
+          "/path/to/.env"
+        ],
+        "env": {
+          "HTTP_PROXY": "http://proxy.example.com:8080",
+          "HTTPS_PROXY": "http://proxy.example.com:8080",
+          "NO_PROXY": "localhost,127.0.0.1,.example.com"
+        }
+      }
+    }
+  }
+}
+```
+
+### Claude Desktop
+
+Add to `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "jenkins": {
+      "command": "npx",
+      "args": [
+        "@rishibhushan/jenkins-mcp-server",
+        "--env-file",
+        "/path/to/.env"
+      ]
+    }
+  }
+}
+```
+
+**Where to find claude_desktop_config.json:**
+- **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
+- **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+- **Linux**: `~/.config/Claude/claude_desktop_config.json`
+
+---
+
+## 💡 Usage Examples
+
+### Natural Language Commands
+
+Once configured, you can use natural language with your MCP client:
+
+```
+"List all Jenkins jobs"
+"List jobs with 'backend' in the name"  - # Filter jobs containing "backend"
+"Show me all production jobs"  - # Filter jobs containing "prod"
+"Show me the last build of my-project"
+"Trigger a build for deploy-prod with parameter env=production"
+"What's in the build queue?"
+"Show me the console output of build #42 for backend-service"
+"Create a new job called test-job by copying prod-job"
+"Disable the old-job"
+```
+
+### Programmatic Usage (Python)
+
+```python
+from config import get_settings
+from jenkins_client import get_jenkins_client
+
+# Load settings
+settings = get_settings()
+
+# Create client
+client = get_jenkins_client(settings)
+
+# List jobs
+all_jobs = client.get_jobs()
+for job in all_jobs:
+    print(f"Job: {job['name']} - Status: {job['color']}")
+
+# Filter in Python
+backend_jobs = [job for job in all_jobs if 'backend' in job['name'].lower()]
+
+# Trigger a build
+result = client.build_job(
+    "my-job",
+    parameters={"BRANCH": "main", "ENV": "staging"}
+)
+print(f"Build queued: {result['queue_id']}")
+print(f"Build number: {result['build_number']}")
+
+# Get console output
+if result['build_number']:
+    output = client.get_build_console_output(
+        "my-job",
+        result['build_number']
+    )
+    print(output)
+```
+
+---
+
+## 🔧 Troubleshooting
+
+### Python Not Found
+```
+Error: Python 3 is required but not found.
+```
+**Solution**: Install Python 3.8+ from https://www.python.org/downloads/
+
+### Configuration Issues
+```
+ERROR: Jenkins configuration is incomplete!
+```
+**Solution**: Verify you have set `JENKINS_URL`, `JENKINS_USERNAME`, and `JENKINS_TOKEN`
+
+Check your configuration:
+```bash
+# View .env file
+cat .env
+
+# Check environment variables
+env | grep JENKINS
+
+# Check VS Code settings
+cat ~/.config/Code/User/settings.json | grep jenkins
+```
+
+### Connection Failed
+```
+Failed to connect to Jenkins at http://localhost:8080
+```
+**Solution**: 
+1. Verify Jenkins is running: `curl http://localhost:8080/api/json`
+2. Check firewall settings
+3. Verify URL is correct (include port if needed)
+4. Test authentication credentials
+
+### Dependency Installation Failed
+```
+Failed to install dependencies
+```
+**Solution**:
+1. Check internet connection
+2. If behind a proxy, set `HTTP_PROXY` and `HTTPS_PROXY` environment variables
+3. Try manual installation: `.venv/bin/pip install -r requirements.txt`
+
+### Enable Debug Logging
+
+Run with verbose flag to see detailed logs:
+```bash
+jenkins-mcp-server --verbose
+```
+
+---
+
+## 🧪 Development & Testing
+
+### Run Tests
+```bash
+# Install test dependencies
+pip install pytest pytest-asyncio
+
+# Run tests
+pytest tests/ -v
+```
+
+### Build Package
+```bash
+# Install build tools
+pip install build
+
+# Build distribution
+python -m build
+
+# This creates:
+# - dist/jenkins_mcp_server-1.0.0.tar.gz
+# - dist/jenkins_mcp_server-1.0.0-py3-none-any.whl
+```
+
+### Local Development
+```bash
+# Clone repository
+git clone https://github.com/rishibhushan/jenkins_mcp_server.git
+cd jenkins_mcp_server
+
+# Install in editable mode
+pip install -e .
+
+# Make changes, then test
+jenkins-mcp-server --verbose
+```
+
+---
+
+## 📚 Project Structure
+
+```
+jenkins_mcp_server/
+├── bin/
+│   └── jenkins-mcp.js          # Node.js wrapper script
+├── src/
+│   └── jenkins_mcp_server/
+│       ├── __init__.py         # Package initialization & main()
+│       ├── __main__.py         # Entry point for python -m
+│       ├── config.py           # Configuration management
+│       ├── jenkins_client.py   # Jenkins API client
+│       └── server.py           # MCP server implementation
+├── tests/                      # Test suite
+├── requirements.txt            # Python dependencies
+├── package.json               # Node.js configuration
+└── README.md                  # This file
+```
+
+---
+
+## 🔒 Security Best Practices
+
+1. **Never commit `.env` files** - Add to `.gitignore`
+2. **Use API tokens**, not passwords - More secure and revocable
+3. **Rotate tokens regularly** - Generate new tokens periodically
+4. **Use environment-specific configs** - Separate dev/staging/prod credentials
+5. **Review permissions** - Only grant necessary Jenkins permissions
+6. **Keep dependencies updated** - Run `pip install --upgrade -r requirements.txt`
+
+---
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/AmazingFeature`)
+3. Commit your changes (`git commit -m 'Add some AmazingFeature'`)
+4. Push to the branch (`git push origin feature/AmazingFeature`)
+5. Open a Pull Request
+
+---
+
+## 📝 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+---
+
+## 🙏 Acknowledgments
+
+- Built on the [Model Context Protocol (MCP)](https://modelcontextprotocol.io/)
+- Powered by [python-jenkins](https://python-jenkins.readthedocs.io/)
+- Inspired by the need for AI-powered DevOps automation
+
+---
+
+## 📞 Support
+
+- **Issues**: https://github.com/rishibhushan/jenkins_mcp_server/issues
+- **Discussions**: https://github.com/rishibhushan/jenkins_mcp_server/discussions
+
+---
+
+## 🗺️ Roadmap
+
+- [ ] Add pipeline support
+- [ ] Multi-Jenkins instance management
+- [ ] Build artifact management
+- [ ] Advanced filtering and search
+- [ ] Real-time build monitoring
+- [ ] Webhook integration
+- [ ] Docker container support
+
+---
+
+**Made with ❤️ by [Rishi Bhushan](https://github.com/rishibhushan)**

package/src/jenkins_mcp_server.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+src/jenkins_mcp_server/__init__.py
+src/jenkins_mcp_server/__main__.py
+src/jenkins_mcp_server/config.py
+src/jenkins_mcp_server/jenkins_client.py
+src/jenkins_mcp_server/server.py
+src/jenkins_mcp_server.egg-info/PKG-INFO
+src/jenkins_mcp_server.egg-info/SOURCES.txt
+src/jenkins_mcp_server.egg-info/dependency_links.txt
+src/jenkins_mcp_server.egg-info/entry_points.txt
+src/jenkins_mcp_server.egg-info/requires.txt
+src/jenkins_mcp_server.egg-info/top_level.txt

package/src/jenkins_mcp_server.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

package/src/jenkins_mcp_server.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+jenkins-mcp-server = jenkins_mcp_server:main

package/src/jenkins_mcp_server.egg-info/requires.txt

@@ -0,0 +1,20 @@
+mcp>=1.0.0
+python-jenkins>=1.8.0
+requests>=2.28.0
+pydantic>=2.0.0
+pydantic-settings>=2.0.0
+python-dotenv>=1.0.0
+urllib3>=2.0.0
+
+[dev]
+pytest>=7.0.0
+pytest-asyncio>=0.21.0
+pytest-cov>=4.0.0
+black>=23.0.0
+ruff>=0.1.0
+mypy>=1.0.0
+
+[test]
+pytest>=7.0.0
+pytest-asyncio>=0.21.0
+pytest-cov>=4.0.0

package/src/jenkins_mcp_server.egg-info/top_level.txt

@@ -0,0 +1 @@
+jenkins_mcp_server