iflow-mcp_developermode-korea_reversecore-mcp 1.0.0__py3-none-any.whl

reversecore_mcp/core/ghidra_manager.py

@@ -0,0 +1,234 @@
+"""
+Ghidra Manager
+
+This module manages the Ghidra JVM lifecycle and project reuse.
+It ensures the JVM is started only once and projects are cached for performance.
+"""
+
+import asyncio
+import threading
+from typing import Any
+
+from reversecore_mcp.core.config import get_config
+from reversecore_mcp.core.logging_config import get_logger
+
+
+# Custom Exceptions for Structured Error Handling
+class GhidraError(Exception):
+    """Base exception for Ghidra operations."""
+
+    pass
+
+
+class DecompilationError(GhidraError):
+    """Raised when decompilation fails."""
+
+    pass
+
+
+logger = get_logger(__name__)
+
+
+class GhidraManager:
+    """
+    Manages Ghidra JVM and project lifecycle.
+
+    Features:
+    - Singleton JVM instance
+    - Project caching
+    - Thread-safe execution
+    """
+
+    _instance = None
+    _lock = threading.RLock()
+
+    def __new__(cls):
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super().__new__(cls)
+                    cls._instance._initialized = False
+        return cls._instance
+
+    def __init__(self):
+        if self._initialized:
+            return
+
+        self._jvm_started = False
+        self._projects: dict[
+            str, Any
+        ] = {}  # Cache for loaded programs (path -> (program, flat_api))
+        self._project_lock = threading.RLock()
+        # Use config value instead of hardcoded 1
+        self._max_projects = get_config().ghidra_max_projects
+        self._initialized = True
+        self._pyghidra = None
+        self._flat_program_api = None
+
+    def _ensure_jvm_started(self):
+        """Start the JVM if not already started."""
+        if self._jvm_started:
+            return
+
+        with self._lock:
+            if self._jvm_started:
+                return
+
+            try:
+                import pyghidra
+                from pyghidra.core import FlatProgramAPI
+
+                logger.info("Starting Ghidra JVM...")
+                # pyghidra.start() is often called automatically on import or first use
+                # but explicit start ensures control
+                try:
+                    pyghidra.start()
+                except Exception as e:
+                    # It might be already running or failed
+                    logger.debug(f"pyghidra.start() result: {e}")
+
+                self._pyghidra = pyghidra
+                self._flat_program_api = FlatProgramAPI
+                self._jvm_started = True
+                logger.info("Ghidra JVM started successfully")
+
+            except ImportError:
+                logger.error("pyghidra not installed")
+                raise ImportError("pyghidra not installed")
+            except Exception as e:
+                logger.error(f"Failed to start Ghidra JVM: {e}")
+                raise
+
+    def _close_project(self, file_path: str, ctx: Any) -> None:
+        """Properly close a Ghidra project context manager."""
+        try:
+            ctx.__exit__(None, None, None)
+            logger.info(f"Closed Ghidra project: {file_path}")
+        except Exception as e:
+            logger.warning(f"Error closing Ghidra project {file_path}: {e}")
+
+    def _get_project(self, file_path: str):
+        """Get or load a project for the given file."""
+        with self._project_lock:
+            if file_path in self._projects:
+                # Move to end (LRU)
+                val = self._projects.pop(file_path)
+                self._projects[file_path] = val
+                return val
+
+            # Evict if needed - properly close the context manager
+            if len(self._projects) >= self._max_projects:
+                oldest_path, (oldest_prog, oldest_api, oldest_ctx) = (
+                    self._projects.popitem()
+                )  # pop first (oldest)
+                logger.info(f"Evicting Ghidra project: {oldest_path}")
+                self._close_project(oldest_path, oldest_ctx)
+
+            logger.info(f"Loading Ghidra project: {file_path}")
+            # We use open_program but we need to keep it alive.
+            # pyghidra.open_program returns a context manager.
+            # We enter it manually.
+            ctx = self._pyghidra.open_program(file_path)
+            flat_api = ctx.__enter__()
+            program = flat_api.getCurrentProgram()
+
+            # Store context so we can exit it on eviction
+            self._projects[file_path] = (program, flat_api, ctx)
+            return program, flat_api, ctx
+
+    def close_all(self) -> None:
+        """Close all cached projects. Call on shutdown to prevent resource leaks."""
+        with self._project_lock:
+            for path, (_prog, _api, ctx) in list(self._projects.items()):
+                self._close_project(path, ctx)
+            self._projects.clear()
+            logger.info("All Ghidra projects closed")
+
+    def decompile(self, file_path: str, function_address: str | None = None) -> str:
+        """
+        Decompile a function or the entire file.
+
+        Args:
+            file_path: Path to the binary
+            function_address: Address of function to decompile (optional)
+
+        Returns:
+            Decompiled C code
+        """
+        self._ensure_jvm_started()
+
+        self._ensure_jvm_started()
+
+        # [PERFORMANCE BOTTLENECK]
+        # Ghidra/JPype requires single-threaded access to the JVM bridge via this lock.
+        # This serializes all decompilation requests.
+        # DO NOT REMOVE this lock without implementing a multi-process worker pool architecture.
+        with self._lock:
+            try:
+                # Get cached project
+                program, flat_api, _ = self._get_project(file_path)
+
+                from ghidra.app.decompiler import DecompInterface
+                from ghidra.util.task import ConsoleTaskMonitor
+
+                decompiler = DecompInterface()
+                decompiler.openProgram(program)
+
+                monitor = ConsoleTaskMonitor()
+
+                if function_address:
+                    # Parse address
+                    addr = flat_api.toAddr(function_address)
+                    if not addr:
+                        # Try adding base address if needed, or assume hex
+                        try:
+                            if function_address.startswith("0x"):
+                                addr = flat_api.toAddr(int(function_address, 16))
+                            else:
+                                # Try to find symbol
+                                funcs = flat_api.getGlobalFunctions(function_address)
+                                if funcs:
+                                    addr = funcs[0].getEntryPoint()
+                        except Exception:  # Catch all exceptions when parsing address
+                            pass
+
+                    if not addr:
+                        raise ValueError(f"Invalid address or symbol: {function_address}")
+
+                    func = flat_api.getFunctionAt(addr)
+                    if not func:
+                        # Try to find nearest function
+                        func = flat_api.getFunctionBefore(addr)
+                        if not func:
+                            raise ValueError(f"No function found at or near {function_address}")
+
+                    res = decompiler.decompileFunction(func, 60, monitor)
+                    if not res.decompileCompleted():
+                        raise DecompilationError(f"Decompilation failed: {res.getErrorMessage()}")
+
+                    return res.getDecompiledFunction().getC()
+                else:
+                    raise NotImplementedError(
+                        "Full file decompilation not supported. Please specify a function."
+                    )
+
+            except Exception as e:
+                logger.error(f"Ghidra decompilation failed: {e}")
+                # Invalidate cache on error
+                with self._project_lock:
+                    if file_path in self._projects:
+                        del self._projects[file_path]
+                raise
+
+    async def decompile_async(self, file_path: str, function_address: str | None = None) -> str:
+        """Execute decompilation asynchronously."""
+        return await asyncio.to_thread(self.decompile, file_path, function_address)
+
+
+# Global instance
+ghidra_manager = GhidraManager()
+
+
+def get_ghidra_manager() -> GhidraManager:
+    """Get the global GhidraManager instance."""
+    return ghidra_manager

reversecore_mcp/core/json_utils.py

@@ -0,0 +1,131 @@
+"""
+High-performance JSON utilities with orjson fallback.
+
+This module provides a drop-in replacement for the standard json module
+with automatic fallback. It uses orjson when available for 3-5x faster
+JSON parsing and serialization, falling back to the standard json module
+if orjson is not installed.
+
+Performance comparison:
+- orjson.loads(): ~3-5x faster than json.loads()
+- orjson.dumps(): ~3-5x faster than json.dumps()
+- Particularly impactful for large JSON objects and hot paths
+"""
+
+import json as _stdlib_json
+from typing import Any
+
+try:
+    import orjson
+
+    _ORJSON_AVAILABLE = True
+    # Expose stdlib JSONDecodeError for consistent error handling
+    JSONDecodeError = _stdlib_json.JSONDecodeError
+
+    def loads(s: str | bytes) -> Any:
+        """
+        Parse JSON with orjson (fast path).
+        Wraps orjson.JSONDecodeError ensuring compatibility with stdlib json.
+        """
+        if isinstance(s, str):
+            s = s.encode("utf-8")
+        try:
+            return orjson.loads(s)
+        except orjson.JSONDecodeError as e:
+            # Re-raise as stdlib JSONDecodeError for compatibility
+            # orjson error message usually contains position info at the end
+            raise _stdlib_json.JSONDecodeError(str(e), str(s), 0) from e
+
+    def dumps(
+        obj: Any,
+        indent: int | None = None,
+        ensure_ascii: bool = True,
+        default: Any = None,
+    ) -> str:
+        """
+        Serialize object to JSON with orjson (fast path).
+
+        Note: orjson only supports 2-space indentation when indent is provided.
+        Any non-None indent value will result in 2-space pretty-printing.
+        This differs slightly from stdlib json which respects the exact indent value.
+
+        Note: orjson always outputs UTF-8 (never escapes non-ASCII).
+        The ensure_ascii parameter is accepted for API compatibility but ignored.
+
+        Args:
+            obj: Python object to serialize
+            indent: If provided (any non-None value), pretty-print with 2-space indentation
+            ensure_ascii: Ignored (orjson always uses UTF-8). Kept for API compatibility.
+            default: Callable to serialize non-serializable objects (passed to stdlib as fallback)
+
+        Returns:
+            JSON string
+        """
+        try:
+            if indent is not None:
+                # orjson only supports 2-space indentation via OPT_INDENT_2
+                # For compatibility, any indent value triggers pretty-printing
+                result = orjson.dumps(obj, option=orjson.OPT_INDENT_2)
+            else:
+                result = orjson.dumps(obj)
+            # orjson returns bytes, convert to str for compatibility
+            return result.decode("utf-8")
+        except TypeError:
+            # orjson can't serialize some types, fall back to stdlib with default
+            return _stdlib_json.dumps(
+                obj, indent=indent, ensure_ascii=ensure_ascii, default=default
+            )
+
+except ImportError:
+    # Fallback to standard library json
+    _ORJSON_AVAILABLE = False
+    # Use stdlib JSONDecodeError for compatibility
+    JSONDecodeError = _stdlib_json.JSONDecodeError
+
+    def loads(s: str | bytes) -> Any:
+        """
+        Parse JSON with standard library (fallback).
+
+        Args:
+            s: JSON string or bytes to parse
+
+        Returns:
+            Parsed Python object
+        """
+        if isinstance(s, bytes):
+            s = s.decode("utf-8")
+        return _stdlib_json.loads(s)
+
+    def dumps(
+        obj: Any,
+        indent: int | None = None,
+        ensure_ascii: bool = True,
+        default: Any = None,
+    ) -> str:
+        """
+        Serialize object to JSON with standard library (fallback).
+
+        Args:
+            obj: Python object to serialize
+            indent: If provided, pretty-print with indentation
+            ensure_ascii: If True, escape non-ASCII characters
+            default: Callable to serialize non-serializable objects
+
+        Returns:
+            JSON string
+        """
+        return _stdlib_json.dumps(obj, indent=indent, ensure_ascii=ensure_ascii, default=default)
+
+
+def is_orjson_available() -> bool:
+    """
+    Check if orjson is available.
+
+    Returns:
+        True if orjson is installed and being used, False if using fallback
+    """
+    return _ORJSON_AVAILABLE
+
+
+# For compatibility, expose the same interface as json module
+__all__ = ["loads", "dumps", "is_orjson_available", "JSONDecodeError"]

reversecore_mcp/core/loader.py

@@ -0,0 +1,73 @@
+"""
+Plugin loader for dynamically discovering and loading plugins.
+"""
+
+import importlib
+import inspect
+import pkgutil
+
+from reversecore_mcp.core.logging_config import get_logger
+from reversecore_mcp.core.plugin import Plugin
+
+logger = get_logger(__name__)
+
+
+class PluginLoader:
+    """Responsible for discovering and loading plugins."""
+
+    def __init__(self):
+        self._plugins: dict[str, Plugin] = {}
+
+    def discover_plugins(
+        self, package_path: str, package_name: str = "reversecore_mcp.tools"
+    ) -> list[Plugin]:
+        """
+        Discover and load plugins from a package directory (including subdirectories).
+
+        Args:
+            package_path: Absolute path to the package directory
+            package_name: Python package name prefix
+
+        Returns:
+            List of instantiated Plugin objects
+        """
+        logger.info(f"Discovering plugins in {package_path}")
+
+        discovered_plugins = []
+
+        # Use walk_packages to recursively iterate over all modules including subdirectories
+        for importer, name, is_pkg in pkgutil.walk_packages(
+            [package_path], prefix=f"{package_name}."
+        ):
+            # Skip __init__ modules and __pycache__ directories
+            if name.endswith(".__init__") or "__pycache__" in name:
+                continue
+
+            try:
+                module = importlib.import_module(name)
+
+                # Find Plugin subclasses in the module
+                for item_name, item in inspect.getmembers(module):
+                    if inspect.isclass(item) and issubclass(item, Plugin) and item is not Plugin:
+                        try:
+                            # Instantiate the plugin
+                            plugin_instance = item()
+                            self._plugins[plugin_instance.name] = plugin_instance
+                            discovered_plugins.append(plugin_instance)
+                            logger.info(f"Loaded plugin: {plugin_instance.name}")
+                        except Exception as e:
+                            logger.error(f"Failed to instantiate plugin {item_name}: {e}")
+
+            except ImportError as e:
+                logger.warning(f"Failed to import module {name}: {e}")
+                continue
+
+        return discovered_plugins
+
+    def get_plugin(self, name: str) -> Plugin | None:
+        """Get a loaded plugin by name."""
+        return self._plugins.get(name)
+
+    def get_all_plugins(self) -> list[Plugin]:
+        """Get all loaded plugins."""
+        return list(self._plugins.values())

reversecore_mcp/core/logging_config.py

@@ -0,0 +1,206 @@
+"""
+Logging configuration for Reversecore_MCP.
+
+This module provides structured logging with JSON output option and log rotation.
+Uses high-performance JSON serialization when available.
+
+Environment Variables:
+    LOG_LEVEL: Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+    LOG_FORMAT: Log format - "human" or "json"
+    LOG_FILE: Path to log file
+"""
+
+import logging
+import os
+import platform
+import sys
+import time
+from logging.handlers import RotatingFileHandler
+from typing import Any
+
+from reversecore_mcp.core import json_utils as json
+from reversecore_mcp.core.config import get_config
+
+
+class JSONFormatter(logging.Formatter):
+    """JSON formatter for structured logging with rich context."""
+
+    def __init__(
+        self,
+        datefmt: str | None = None,
+        include_extra: bool = True,
+        include_hostname: bool = True,
+    ):
+        super().__init__(datefmt=datefmt)
+        self.include_extra = include_extra
+        self.include_hostname = include_hostname
+        self._hostname = platform.node() if include_hostname else None
+
+    def format(self, record: logging.LogRecord) -> str:
+        """Format log record as JSON with structured fields."""
+        log_data: dict[str, Any] = {
+            "timestamp": time.strftime("%Y-%m-%dT%H:%M:%S", time.gmtime(record.created))
+            + f".{int(record.msecs):03d}Z",
+            "level": record.levelname,
+            "logger": record.name,
+            "message": record.getMessage(),
+            "module": record.module,
+            "function": record.funcName,
+            "line": record.lineno,
+        }
+
+        # Add hostname for distributed systems
+        if self._hostname:
+            log_data["hostname"] = self._hostname
+
+        # Add process/thread info for debugging concurrency issues
+        log_data["process"] = {"id": record.process, "name": record.processName}
+        log_data["thread"] = {"id": record.thread, "name": record.threadName}
+
+        # Add extra fields if present (tool execution context)
+        if self.include_extra:
+            extra_fields = {}
+            for key in ("tool_name", "file_name", "execution_time_ms", "error_code", "binary_path"):
+                if hasattr(record, key):
+                    extra_fields[key] = getattr(record, key)
+
+            # Include any custom extra fields
+            for key, value in record.__dict__.items():
+                if key.startswith("ctx_"):  # Convention: ctx_ prefix for context fields
+                    extra_fields[key[4:]] = value  # Strip ctx_ prefix
+
+            if extra_fields:
+                log_data["context"] = extra_fields
+
+        # Add exception info if present
+        if record.exc_info:
+            log_data["exception"] = {
+                "type": record.exc_info[0].__name__ if record.exc_info[0] else None,
+                "message": str(record.exc_info[1]) if record.exc_info[1] else None,
+                "traceback": self.formatException(record.exc_info),
+            }
+
+        # Safe serialization with default=str to prevent crashes on non-serializable objects
+        return json.dumps(log_data, default=str)
+
+
+class ContextAdapter(logging.LoggerAdapter):
+    """Logger adapter that adds contextual information to log records."""
+
+    def process(self, msg: str, kwargs: dict[str, Any]) -> tuple[str, dict[str, Any]]:
+        """Add extra context to log message."""
+        extra = kwargs.get("extra", {})
+        extra.update(self.extra)
+        kwargs["extra"] = extra
+        return msg, kwargs
+
+
+def setup_logging() -> None:
+    """
+    Configure logging for Reversecore_MCP.
+
+    Logging configuration:
+    - Log level from settings (default: INFO)
+    - Log format from settings (default: human-readable)
+    - Log file from settings (default: /tmp/reversecore/app.log)
+    - Log rotation: 100MB max size, keep 10 backup files
+
+    When LOG_FORMAT=json:
+    - Console output is JSON formatted
+    - File output is JSON formatted
+    - Structured fields include timestamp, level, logger, message, context
+
+    When LOG_FORMAT=human (default):
+    - Console output is human-readable
+    - File output is human-readable
+    """
+    settings = get_config()
+    log_level = settings.log_level.upper()
+    log_format = settings.log_format.lower()
+    log_file = settings.log_file
+
+    # Create log directory if it doesn't exist
+    try:
+        log_file.parent.mkdir(parents=True, exist_ok=True)
+    except (PermissionError, OSError):
+        pass
+
+    # Configure root logger
+    logger = logging.getLogger("reversecore_mcp")
+    logger.setLevel(getattr(logging, log_level, logging.INFO))
+
+    # Remove existing handlers
+    logger.handlers.clear()
+
+    # Determine formatter based on LOG_FORMAT
+    if log_format == "json":
+        console_formatter: logging.Formatter = JSONFormatter()
+        file_formatter: logging.Formatter = JSONFormatter()
+    else:
+        human_format = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+        datefmt = "%Y-%m-%d %H:%M:%S"
+        console_formatter = logging.Formatter(human_format, datefmt=datefmt)
+        file_formatter = logging.Formatter(human_format, datefmt=datefmt)
+
+    # Console handler
+    console_handler = logging.StreamHandler(sys.stderr)
+    # Unlock console level to allow DEBUG logs if configured
+    console_handler.setLevel(getattr(logging, log_level, logging.INFO))
+    console_handler.setFormatter(console_formatter)
+    logger.addHandler(console_handler)
+
+    # File handler with rotation (only if we can write to the log file)
+    try:
+        file_handler = RotatingFileHandler(
+            str(log_file),
+            maxBytes=100 * 1024 * 1024,  # 100MB
+            backupCount=10,
+            encoding="utf-8",
+        )
+        file_handler.setLevel(logging.DEBUG)
+        file_handler.setFormatter(file_formatter)
+        logger.addHandler(file_handler)
+    except (PermissionError, OSError) as e:
+        logger.warning(
+            f"Could not create log file handler for {log_file}: {e}. Logging to console only."
+        )
+
+    # Prevent propagation to root logger
+    logger.propagate = False
+
+
+def get_logger(name: str) -> logging.Logger:
+    """
+    Get a logger instance for a module.
+
+    Args:
+        name: Logger name (typically __name__)
+
+    Returns:
+        Logger instance
+    """
+    return logging.getLogger(f"reversecore_mcp.{name}")
+
+
+def get_context_logger(name: str, **context: Any) -> ContextAdapter:
+    """
+    Get a logger with persistent context fields.
+
+    This is useful for adding context that should appear in all log messages,
+    such as tool name, file being analyzed, etc.
+
+    Args:
+        name: Logger name (typically __name__)
+        **context: Key-value pairs to include in all log messages
+
+    Returns:
+        ContextAdapter with the given context
+
+    Example:
+        logger = get_context_logger(__name__, tool_name="neural_decompile")
+        logger.info("Starting analysis")  # Includes tool_name in output
+    """
+    base_logger = get_logger(name)
+    # Prefix context keys with ctx_ to avoid conflicts
+    prefixed_context = {f"ctx_{k}": v for k, v in context.items()}
+    return ContextAdapter(base_logger, prefixed_context)