import logging import os import sys import argparse from pathlib import Path from typing import Optional # CRITICAL: Ensure package root is in sys.path for MCP stdio mode # When running via stdio (Claude CLI), PYTHONPATH may not be set _package_root = Path(__file__).parent.parent.parent if str(_package_root) not in sys.path: sys.path.insert(0, str(_package_root)) # CRITICAL: Fix LOG_LEVEL environment variable before FastMCP imports _original_log_level = os.environ.get("LOG_LEVEL", None) if _original_log_level and _original_log_level.lower() == "error": os.environ["LOG_LEVEL"] = "ERROR" elif _original_log_level and _original_log_level.lower() in [ "debug", "info", "warning", "critical", ]: os.environ["LOG_LEVEL"] = _original_log_level.upper() from .core import mcp from .transport import detect_transport_mode from .registry import ensure_tools_registered from vibe_check.tools.config_validation import ( validate_configuration, format_validation_results, log_validation_results, ) from .utils import get_version # Import the new function # Configure logging with safe file handler (handle read-only filesystems in MCP mode) def _setup_logging(): """Setup logging with graceful fallback for read-only filesystems.""" # CRITICAL: Send logs to stderr, not stdout, to preserve stdout for JSON-RPC protocol # in stdio transport mode (used by Codex, Claude CLI, etc) handlers = [logging.StreamHandler(sys.stderr)] # Try to add file handler in a writable location try: import tempfile log_dir = tempfile.gettempdir() log_file = os.path.join(log_dir, "vibe_check.log") handlers.append(logging.FileHandler(log_file)) except (OSError, PermissionError): # Skip file logging if filesystem is read-only (common in MCP stdio mode) pass logging.basicConfig( level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", handlers=handlers, ) _setup_logging() logger = logging.getLogger(__name__) def run_server( transport: Optional[str] = None, host: Optional[str] = None, port: Optional[int] = None, ): """ Start the Vibe Check MCP server with configurable transport. Args: transport: Override transport mode ('stdio' or 'streamable-http') host: Host for HTTP transport (ignored for stdio) port: Port for HTTP transport (ignored for stdio) Includes proper error handling and graceful startup/shutdown. """ try: version = get_version() # Get version dynamically logger.info("🚀 Starting Vibe Check MCP Server...") logger.info(f"📌 Version: {version}") workspace_env = os.environ.get("WORKSPACE") if workspace_env: logger.info(f"✅ WORKSPACE configured: {workspace_env}") else: logger.warning("⚠️ WORKSPACE environment variable not set") logger.warning( " vibe_check_mentor will provide generic advice without code analysis" ) logger.warning( ' To enable: claude mcp add ... -e WORKSPACE="/path/to/project" ...' ) logger.info("🔍 Validating configuration for Claude CLI and MCP integration...") can_start, validation_results = validate_configuration() log_validation_results(validation_results) if not can_start: logger.error( "❌ Critical configuration validation failed - server cannot start safely" ) print("\n" + format_validation_results(validation_results)) sys.exit(1) warnings = [ r for r in validation_results if not r.success and r.level.value == "warning" ] if warnings: logger.warning( f"⚠️ Configuration validation completed with {len(warnings)} warnings" ) else: logger.info("✅ Configuration validation passed - all systems ready") logger.info("📊 Core detection engine: 87.5% accuracy, 0% false positives") logger.info("🔧 Server ready for MCP protocol connections") ensure_tools_registered(mcp) transport_mode = transport or detect_transport_mode() if transport_mode == "stdio": logger.info("🔗 Using stdio transport for Claude Desktop/Code integration") os.environ.setdefault("FASTMCP_SERVER_STRICT_INIT", "false") os.environ.setdefault("FASTMCP_SERVER_PROTOCOL_COMPLIANCE", "relaxed") # Fix LOG_LEVEL before mcp.run() calls - FastMCP uses case_sensitive=True _current_log_level = os.environ.get("LOG_LEVEL", None) if _current_log_level and _current_log_level.lower() in [ "debug", "info", "warning", "error", "critical", ]: os.environ["LOG_LEVEL"] = _current_log_level.upper() try: mcp.run(transport="stdio") except Exception as e: logger.error(f"Server failed to start with stdio transport: {e}") logger.info("Attempting fallback startup with minimal configuration...") # Clear problematic env vars for fallback if "LOG_LEVEL" in os.environ: del os.environ["LOG_LEVEL"] mcp.run() else: server_host = host or os.environ.get("MCP_SERVER_HOST", "0.0.0.0") server_port = port or int(os.environ.get("MCP_SERVER_PORT", "8001")) logger.info( f"🌐 Using streamable-http transport on http://{server_host}:{server_port}/mcp" ) mcp.run(transport="streamable-http", host=server_host, port=server_port) except KeyboardInterrupt: logger.info("🛑 Server shutdown requested by user") except Exception as e: logger.error(f"❌ Server startup failed: {e}") sys.exit(1) finally: logger.info("✅ Vibe Check MCP server shutdown complete") def main(): """Entry point for direct server execution with CLI argument support.""" parser = argparse.ArgumentParser(description="Vibe Check MCP Server") parser.add_argument( "--transport", choices=["stdio", "streamable-http"], help="MCP transport mode (auto-detected if not specified)", ) parser.add_argument( "--stdio", action="store_const", const="stdio", dest="transport", help="Use stdio transport (shorthand for --transport stdio)", ) parser.add_argument( "--host", default=None, help="Host for HTTP transport (default: 0.0.0.0)" ) parser.add_argument( "--port", type=int, default=None, help="Port for HTTP transport (default: 8001)" ) args = parser.parse_args() run_server(transport=args.transport, host=args.host, port=args.port) if __name__ == "__main__": main()