@rishibhushan/jenkins-mcp-server 1.1.16 → 1.1.18

package/README.md

@@ -7,9 +7,15 @@ Designed to work seamlessly with automation clients such as:
 - 🖥️ **Claude Desktop** - AI-powered Jenkins automation
 - 🔌 **Any MCP-compatible client** - Universal compatibility
 
-## ✨ What's New in v1.1.0
+## ✨ What's New in v1.1.16
 
-### 🚀 Performance Enhancements
+### 🚀 Latest Improvements (v1.1.16)
+- ⚡ **Instant startup** - Server initialization in <1 second (previously 30-60s)
+- 🔧 **Simplified architecture** - Streamlined Node.js wrapper for better reliability
+- 🌐 **Universal compatibility** - Works seamlessly with VSCode, Claude Desktop, and all MCP clients
+- 🐛 **Critical fixes** - Resolved initialization timeouts and network blocking issues
+
+### 🚀 Performance Enhancements (v1.1.0)
 - ⚡ **10x faster** - Client connection caching for repeated operations
 - 📊 **Smart caching** - Job list caching with 30-60s TTL (5-10x improvement)
 - 🎯 **Optimized queries** - Reduced API calls by 33-83%
@@ -252,6 +258,15 @@ npx @rishibhushan/jenkins-mcp-server --env-file .env
 # OR if .env file is located in /path/to/.env
 npx @rishibhushan/jenkins-mcp-server --env-file /path/to/.env
 ```
+**NPX Usage:**
+- Always use `--yes` flag with npx for automatic package installation
+- First run may take 10-20 seconds to set up Python environment
+- Subsequent runs are instant (environment is cached)
+
+**Example:**
+````bash
+npx --yes @rishibhushan/jenkins-mcp-server --env-file .env
+````
 
 ### Option 2: Global Installation
 ```bash
@@ -267,12 +282,12 @@ jenkins-mcp-server --env-file .env
 npx github:rishibhushan/jenkins_mcp_server --env-file .env
 ```
 
----
-
 This automatically:
 - ✅ Installs all dependencies
 - ✅ Starts the Jenkins MCP server
 
+---
+
 ### Method 2: Direct Python Execution
 
 ```bash
@@ -307,11 +322,13 @@ Options:
 
 ---
 
-## 🔌 Integration Examples
+## 🔌 Integration with VSCode
+
+1. **Install VSCode MCP Extension** (if not already installed)
 
-### VS Code MCP Client
+2. **Configure the server** in your workspace or user settings:
 
-Add to your VS Code `mcp.json`:
+**Option A: Using `mcp.json` (Recommended)**
 
 ```json
 {
@@ -327,7 +344,9 @@ Add to your VS Code `mcp.json`:
 }
 ```
 
-Or `setting.json` with `.env` file and proxy settings:
+**Option B: Using settings.json**
+
+Add to your VSCode `settings.json`. With `.env` file, `--verbose`, and proxy settings:
 ```json
 {
   "mcp": {
@@ -339,7 +358,7 @@ Or `setting.json` with `.env` file and proxy settings:
           "@rishibhushan/jenkins-mcp-server",
           "--verbose",
           "--env-file",
-          "/path/to/.env"
+          "/absolute/path/to/your/.env"
         ],
         "env": {
           "HTTP_PROXY": "http://proxy.example.com:8080",
@@ -351,11 +370,36 @@ Or `setting.json` with `.env` file and proxy settings:
   }
 }
 ```
+**Important:**
+- Always use **absolute paths** for the `--env-file` parameter
+- Restart VSCode completely after configuration changes
+- Check Output → Model Context Protocol for connection status
 
-### Claude Desktop
+3. **Verify connection:**
+   - Open Command Palette (Cmd/Ctrl+Shift+P)
+   - Type "MCP" to see available commands
+   - Should see "Discovered 26 tools" in Output panel
 
-Add to `claude_desktop_config.json`:
+#### Troubleshooting VSCode Connection
+
+If VSCode shows "Waiting for initialize response":
+1. Ensure `.env` file path is **absolute**, not relative
+2. Verify `.env` file has correct Jenkins credentials
+3. Restart VSCode completely (quit and reopen)
+4. Check Output → Model Context Protocol for error messages
+5. Try running manually first: `npx --yes @rishibhushan/jenkins-mcp-server --env-file /path/to/.env`
+
+## 🤖 Integration with Claude Desktop
 
+1. **Locate Claude Desktop config:**
+   - **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+   - **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
+   - **Linux**: `~/.config/Claude/claude_desktop_config.json`
+
+   
+2. **Add server configuration:**
+
+Add to `claude_desktop_config.json`:
 ```json
 {
   "mcpServers": {
@@ -364,20 +408,28 @@ Add to `claude_desktop_config.json`:
       "args": [
         "@rishibhushan/jenkins-mcp-server",
         "--env-file",
-        "/path/to/.env"
+        "/absolute/path/to/your/.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`
+3. **Restart Claude Desktop** completely
+
+4. **Verify:**
+   - You should see a 🔌 icon in Claude's input area
+   - Click it to see "jenkins" server with 26 tools
+
+#### Troubleshooting Claude Desktop
+Common issues:
+- **Server disconnects after 60s:** Make sure you're on VPN if Jenkins requires it
+- **No tools appear:** Check the config file path and restart Claude Desktop
+- **Connection timeout:** Verify Jenkins URL is accessible from your network
 
 ---
 
+
 ## 🏢 Corporate Network / Proxy Setup
 
 If you're behind a corporate proxy or firewall:
@@ -501,6 +553,36 @@ if result['build_number']:
 
 ---
 
+## 🔍 Quick Troubleshooting
+
+### Server won't start
+```bash
+# Test if server works manually
+npx --yes @rishibhushan/jenkins-mcp-server --env-file /path/to/.env
+
+# Should start and wait for input (Ctrl+C to exit)
+```
+
+### VSCode/Claude Desktop can't connect
+- ✅ Use **absolute paths** for `--env-file`
+- ✅ Include `--yes` flag with npx
+- ✅ Restart application completely after config changes
+- ✅ Check if Jenkins is accessible (try in browser)
+- ✅ Verify `.env` file has correct credentials
+
+### Server connects but times out
+- ✅ Connect to VPN if Jenkins is on private network
+- ✅ Check firewall settings
+- ✅ Verify Jenkins URL is correct
+- ✅ Test with: `curl -I http://your-jenkins-url:8080`
+
+### "Module not found" errors
+- ✅ Delete `.venv` folder and let it reinstall
+- ✅ Clear npm cache: `npm cache clean --force`
+- ✅ Try with latest version: `npx --yes @rishibhushan/jenkins-mcp-server@latest`
+
+---
+
 ## 🔧 Troubleshooting
 
 ### Common Issues
@@ -1133,17 +1215,19 @@ jenkins-mcp-server --verbose
 ```
 jenkins_mcp_server/
 ├── bin/
-│   └── jenkins-mcp.js          # Node.js wrapper script
+│   └── jenkins-mcp.js          # Simplified Node.js wrapper (v1.1.16+)
 ├── 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
+│       ├── jenkins_client.py   # Jenkins API client (with caching)
+│       ├── cache.py            # Smart caching layer
+│       ├── metrics.py          # Performance telemetry
+│       └── server.py           # MCP server implementation (26 tools)
 ├── tests/                      # Test suite
 ├── requirements.txt            # Python dependencies
-├── package.json               # Node.js configuration
+├── package.json               # Node.js configuration (ES modules)
 └── README.md                  # This file
 ```
 

package/bin/jenkins-mcp.js

@@ -13,12 +13,14 @@ const IS_WINDOWS = process.platform === "win32";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const PACKAGE_ROOT = path.resolve(__dirname, "..");
+const isVerbose = process.argv.includes('--verbose');
 
 /**
  * Debug (stderr only – safe for MCP)
  */
-console.error("[jenkins-mcp] package root:", PACKAGE_ROOT);
-
+ if (isVerbose) {
+  console.error("[jenkins-mcp] package root:", PACKAGE_ROOT);
+}
 /**
  * Resolve Python executable inside packaged venv
  */
@@ -30,15 +32,21 @@ function run(cmd, args, cwd) {
   return new Promise((resolve, reject) => {
     const p = spawn(cmd, args, {
       cwd,
-      stdio: ["ignore", "pipe", "pipe"], // no stdout leakage
+      stdio: ["ignore", "pipe", "pipe"], // Always pipe stdout/stderr
     });
 
+    // Handle stdout
     p.stdout.on("data", (d) => {
-      console.error(d.toString()); // redirect to stderr
+      if (isVerbose) {
+        console.error(d.toString()); // Only show if verbose
+      }
     });
 
+    // Handle stderr
     p.stderr.on("data", (d) => {
-      console.error(d.toString());
+      if (isVerbose) {
+        console.error(d.toString()); // Only show if verbose
+      }
     });
 
     p.on("exit", (code) =>
@@ -49,11 +57,15 @@ function run(cmd, args, cwd) {
 
 async function ensureVenv() {
   if (!fs.existsSync(pythonPath)) {
-    console.error("[jenkins-mcp] Python venv not found, creating...");
+    if (isVerbose) {
+      console.error("[jenkins-mcp] Python venv not found, creating...");
+    }
     const venvPython = IS_WINDOWS ? "python" : "python3";
     await run(venvPython, ["-m", "venv", ".venv"], PACKAGE_ROOT);
   } else {
-    console.error("[jenkins-mcp] Python venv exists, ensuring dependencies...");
+    if (isVerbose) {
+      console.error("[jenkins-mcp] Python venv exists, ensuring dependencies...");
+    }
   }
 
   const pipArgs = ["-m", "pip", "install", "-r", "requirements.txt"];
@@ -73,14 +85,18 @@ async function ensureVenv() {
 
   await run(pythonPath, pipArgs, PACKAGE_ROOT);
 
-  console.error("[jenkins-mcp] Python environment ready");
+    if (isVerbose) {
+      console.error("[jenkins-mcp] Python environment ready");
+    }
 }
 
 (async () => {
   try {
     await ensureVenv();
   } catch (err) {
-    console.error("[jenkins-mcp] Bootstrap failed:", err);
+    if (isVerbose) {
+      console.error("[jenkins-mcp] Bootstrap failed:", err);
+    }
     process.exit(1);
   }
 
@@ -99,8 +115,10 @@ async function ensureVenv() {
     ...args,
   ];
 
-  console.error("[jenkins-mcp] Python:", pythonPath);
-  console.error("[jenkins-mcp] Args:", pythonArgs.join(" "));
+  if (isVerbose) {
+    console.error("[jenkins-mcp] Python:", pythonPath);
+    console.error("[jenkins-mcp] Args:", pythonArgs.join(" "));
+  }
 
   /**
    * Spawn Python MCP server
@@ -119,14 +137,18 @@ async function ensureVenv() {
    */
   child.on("exit", (code, signal) => {
     if (signal) {
-      console.error("[jenkins-mcp] exited due to signal:", signal);
+      if (isVerbose) {
+        console.error("[jenkins-mcp] exited due to signal:", signal);
+      }
       process.exit(1);
     }
     process.exit(code ?? 0);
   });
 
   child.on("error", (err) => {
-    console.error("[jenkins-mcp] failed to start:", err);
+    if (isVerbose) {
+      console.error("[jenkins-mcp] failed to start:", err);
+    }
     process.exit(1);
   });
 })();

package/package.json

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

package/src/jenkins_mcp_server/__init__.py

@@ -10,6 +10,8 @@ import logging
 import sys
 
 from .config import get_settings, get_default_settings
+from .verbose import set_verbose, vprint
+from .version import __version__
 from . import server
 
 
@@ -43,7 +45,6 @@ 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,
@@ -83,7 +84,7 @@ Configuration Priority:
     parser.add_argument(
         '--version',
         action='version',
-        version='jenkins-mcp-server 1.0.0'
+        version=f'jenkins-mcp-server {__version__}'
     )
 
     parser.add_argument(
@@ -92,26 +93,27 @@ 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)
+    set_verbose(args.verbose)
+
+    vprint(f"=== Args parsed: env_file={args.env_file}, verbose={args.verbose} ===")
 
     # Setup logging first
-    print("=== Setting up logging ===", file=sys.stderr, flush=True)
+    vprint("=== Setting up logging ===")
     setup_logging(args.verbose)
     logger = logging.getLogger(__name__)
-    print("=== Logging configured ===", file=sys.stderr, flush=True)
+    vprint("=== Logging configured ===")
 
     try:
         # Load settings based on arguments
-        print("=== Loading Jenkins configuration ===", file=sys.stderr, flush=True)
+        vprint("=== Loading Jenkins configuration ===")
         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)
+        vprint(f"=== Settings loaded: url={settings.url}, configured={settings.is_configured} ===")
 
         # Validate configuration
         if not settings.is_configured:
@@ -125,27 +127,27 @@ Configuration Priority:
             sys.exit(1)
 
         # Log configuration summary
-        print("=== Configuration validated ===", file=sys.stderr, flush=True)
+        vprint("=== Configuration validated ===")
         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)
+        vprint("=== Setting server settings ===")
         server.set_jenkins_settings(settings)
-        print("=== Server settings configured ===", file=sys.stderr, flush=True)
+        vprint("=== Server settings configured ===")
 
         # Run the server
-        print("=== Starting asyncio server ===", file=sys.stderr, flush=True)
+        vprint("=== Starting asyncio server ===")
         logger.info("Starting Jenkins MCP Server...")
         asyncio.run(server.main())
 
     except KeyboardInterrupt:
-        print("=== Server stopped by user ===", file=sys.stderr, flush=True)
+        vprint("=== Server stopped by user ===")
         logger.info("Server stopped by user")
         sys.exit(0)
     except Exception as e:
-        print(f"=== EXCEPTION: {e} ===", file=sys.stderr, flush=True)
+        vprint(f"=== EXCEPTION: {e} ===")
         logger.error(f"Failed to start server: {e}", exc_info=args.verbose)
         import traceback
         traceback.print_exc(file=sys.stderr)
@@ -153,5 +155,4 @@ Configuration Priority:
 
 
 # Package metadata
-__version__ = "1.0.0"
-__all__ = ['main', 'server']
+__all__ = ['main', 'server', '__version__']

package/src/jenkins_mcp_server/config.py

@@ -18,10 +18,11 @@ from typing import Any, Dict, Optional
 from pydantic import Field, field_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
+from .verbose import vprint
+
 # Configure logging
 logger = logging.getLogger(__name__)
 
-
 class JenkinsSettings(BaseSettings):
     """
     Jenkins connection settings with support for multiple configuration sources.
@@ -275,25 +276,23 @@ 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)
+    vprint(f"=== config.load_settings called: env_file={env_file}, load_vscode={load_vscode} ===")
 
     # Start with environment variables and .env file
     if env_file:
-        print(f"=== Using custom env file: {env_file} ===", file=sys.stderr, flush=True)
+        vprint(f"=== Using custom env file: {env_file} ===")
         settings = JenkinsSettings(_env_file=env_file)
     else:
-        print("=== Using default .env ===", file=sys.stderr, flush=True)
+        vprint("=== Using default .env ===")
         settings = JenkinsSettings()
 
-    print(f"=== Initial settings: url={settings.url} ===", file=sys.stderr, flush=True)
+    vprint(f"=== Initial settings: url={settings.url} ===")
 
     # Override with VS Code settings if requested
     if load_vscode:
-        print("=== Loading VS Code settings ===", file=sys.stderr, flush=True)
+        vprint("=== Loading VS Code settings ===")
         vscode_settings = VSCodeSettingsLoader.load()
-        print(f"=== VS Code settings loaded: {vscode_settings is not None} ===", file=sys.stderr, flush=True)
+        vprint(f"=== VS Code settings loaded: {vscode_settings is not None} ===")
         if vscode_settings:
             # Merge VS Code settings into our settings object
             for key in ['url', 'username', 'password', 'token', 'timeout', 'connect_timeout',
@@ -303,14 +302,13 @@ def load_settings(
                     setattr(settings, key, vscode_value)
 
     # Apply direct overrides (highest priority)
-    print("=== Applying overrides ===", file=sys.stderr, flush=True)
+    vprint("=== Applying overrides ===")
     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)
+    vprint(f"=== Final settings: url={settings.url}, configured={settings.is_configured} ===")
     settings.log_config()
 
     return settings

package/src/jenkins_mcp_server/server.py

@@ -6,12 +6,14 @@ Provides MCP protocol handlers for Jenkins operations including:
 - Prompts (analysis templates)
 - Tools (Jenkins operations)
 """
+from __future__ import annotations
 
 import asyncio
 import json
 import logging
 import sys
 import time
+from datetime import datetime
 from typing import Optional
 
 import mcp.server.stdio
@@ -24,6 +26,8 @@ from .cache import get_cache_manager
 from .config import JenkinsSettings, get_default_settings
 from .jenkins_client import get_jenkins_client
 from .metrics import get_metrics_collector, record_tool_execution
+from .verbose import vprint, _VERBOSE
+from .version import __version__
 
 # Configure logging
 logger = logging.getLogger(__name__)
@@ -458,7 +462,7 @@ async def _tool_trigger_multiple_builds(client, args):
 @server.list_tools()
 async def handle_list_tools() -> list[types.Tool]:
     """List available tools for interacting with Jenkins"""
-    print("=== list_tools CALLED ===", file=sys.stderr, flush=True)
+    vprint("=== list_tools CALLED ===")
     tools = [
         # Build Operations
         types.Tool(
@@ -1902,42 +1906,85 @@ async def main():
     """Run the Jenkins MCP server"""
     try:
         # Add explicit stderr debug
-        print("=== main() entered ===", file=sys.stderr, flush=True)
+        vprint("=== main() entered ===")
 
         # Verify settings are configured
         settings = get_settings()
-        print(f"=== Settings verified: {settings.is_configured} ===", file=sys.stderr, flush=True)
+        vprint(f"=== Settings verified: {settings.is_configured} ===")
 
         if not settings.is_configured:
             logger.error("Jenkins settings not configured!")
             sys.exit(1)
 
-        print(f"=== About to log startup message ===", file=sys.stderr, flush=True)
-        logger.info(f"Starting Jenkins MCP Server v1.0.0")
+        vprint(f"=== About to log startup message ===")
+        logger.info(f"Starting Jenkins MCP Server v{__version__}")
         logger.info(f"Connected to: {settings.url}")
-        print(f"=== Startup messages logged ===", file=sys.stderr, flush=True)
+        vprint(f"=== Startup messages logged ===")
 
         # Run the server using stdin/stdout streams
-        print("=== About to create stdio_server ===", file=sys.stderr, flush=True)
+        vprint("=== About to create stdio_server ===")
         async with mcp.server.stdio.stdio_server() as (read_stream, write_stream):
-            print("=== stdio_server created ===", file=sys.stderr, flush=True)
-            print("=== About to call server.run() ===", file=sys.stderr, flush=True)
+            vprint("=== stdio_server created ===")
+            vprint("=== About to call server.run() ===")
+
+            now_local = datetime.now().astimezone()
+            formatted_date = now_local.strftime("%a %b %d %H:%M:%S %Z %Y")
+
+            print(f"\n------ JENKINS MCP SERVER STARTUP ------")
+            print(f"MCP Server started successfully on {formatted_date}")
+            print(f"Press Ctrl+C to stop the server")
+            print(f"----------------------------------------")
+            if _VERBOSE:
+                vprint(f"Jenkins MCP Server v{__version__}")
+                vprint(f"Connected to: {settings.url}")
 
             await server.run(
                 read_stream,
                 write_stream,
                 InitializationOptions(
                     server_name="jenkins-mcp-server",
-                    server_version="1.0.0",
+                    server_version=__version__,
                     capabilities=server.get_capabilities(
                         notification_options=NotificationOptions(),
                         experimental_capabilities={},
                     ),
                 ),
             )
-            print("=== server.run() completed ===", file=sys.stderr, flush=True)
+            vprint("=== server.run() completed ===")
     except KeyboardInterrupt:
-        logger.info("Server stopped by user")
-    except Exception as e:
-        logger.error(f"Server error: {e}", exc_info=True)
-        sys.exit(1)
+        vprint("=== Received interrupt signal ===")
+        if not _VERBOSE:
+            logger.info("Server stopped")
+
+    except BaseException as e:
+        # Catch BaseExceptionGroup (Python 3.11+) and regular exceptions
+        if type(e).__name__ == 'ExceptionGroup' or type(e).__name__ == 'BaseExceptionGroup':
+            # Handle exception group
+            vprint("=== Handling exception group ===")
+            exceptions = getattr(e, 'exceptions', [e])
+
+            # Check if all exceptions are OSError with errno 5 (expected on Ctrl+C)
+            all_io_errors = all(
+                isinstance(exc, OSError) and getattr(exc, 'errno', None) == 5
+                for exc in exceptions
+            )
+
+            if all_io_errors:
+                vprint("=== I/O error (stdin closed) ===")
+                if not _VERBOSE:
+                    logger.info("Server stopped")
+                # Clean exit - don't re-raise
+            else:
+                # Some other error
+                for exc in exceptions:
+                    logger.error(f"Server error: {exc}", exc_info=True)
+                sys.exit(1)
+        elif isinstance(e, (OSError, IOError)) and getattr(e, 'errno', None) == 5:
+            # Regular OSError with errno 5
+            vprint("=== I/O error (stdin closed) ===")
+            if not _VERBOSE:
+                logger.info("Server stopped")
+        else:
+            # Some other error - re-raise
+            logger.error(f"Unexpected error: {e}", exc_info=True)
+            raise

package/src/jenkins_mcp_server/verbose.py

@@ -0,0 +1,19 @@
+"""Shared verbose logging utility"""
+import sys
+
+# Global verbose flag
+_VERBOSE = False
+
+def set_verbose(verbose: bool):
+    """Set the global verbose flag"""
+    global _VERBOSE
+    _VERBOSE = verbose
+
+def vprint(msg: str):
+    """Print message only if verbose mode is enabled"""
+    if _VERBOSE:
+        print(msg, file=sys.stderr, flush=True)
+
+def is_verbose() -> bool:
+    """Check if verbose mode is enabled"""
+    return _VERBOSE

package/src/jenkins_mcp_server/version.py

@@ -0,0 +1,33 @@
+"""Version management - reads from package.json"""
+import json
+import os
+from pathlib import Path
+
+
+def get_version() -> str:
+    """
+    Read version from package.json.
+    Falls back to a default if package.json is not found.
+    """
+    try:
+        # Get the project root (3 levels up from this file)
+        # src/jenkins_mcp_server/version.py -> project root
+        current_file = Path(__file__)
+        project_root = current_file.parent.parent.parent
+        package_json_path = project_root / "package.json"
+
+        if package_json_path.exists():
+            with open(package_json_path, 'r') as f:
+                package_data = json.load(f)
+                return package_data.get('version', '0.0.0')
+        else:
+            # Fallback if package.json not found
+            return '0.0.0'
+
+    except Exception:
+        # If anything goes wrong, return a safe default
+        return '0.0.0'
+
+
+# Module-level constant
+__version__ = get_version()