Claude-generated plugin guards omitted dangerous Python modules. A plugin that bypassed the static scan could import them and escape the sandbox.

++This module manages the lifecycle of plugins including discovery, loading,+validation, and execution. It enforces security boundaries and ensures+plugins never access sensitive data.++Security Features:+- Capability-based security model+- Plugin validation and sandboxing+- Resource usage monitoring and limits+- Audit logging for all plugin operations+"""++import importlib+import importlib.util+import logging+import os+import sys+import threading+import time+from pathlib import Path+from typing import Any, Dict, List, Optional, Set, Type++from .plugin_base import (+    BasePlugin,+    PluginCapability,+    PluginResult,+    PluginSecurityContext,

++class PluginRegistration:+    """+    Registration record for a plugin including metadata and security info.+    """++    def __init__(self, plugin: BasePlugin, file_path: str, enabled: bool = True):+        self.plugin = plugin+        self.file_path = file_path+        self.enabled = enabled+        self.load_time = time.time()+        self.last_used = None+        self.usage_count = 0+        self.error_count = 0+        self.capabilities = plugin.get_required_capabilities()++    def record_usage(self, success: bool = True):+        """Record plugin usage statistics."""+        self.usage_count += 1+        self.last_used = time.time()+        if not success:

+    Security Architecture:+    - All plugins run in isolated sandboxes+    - Capabilities are validated before plugin execution+    - Resource usage is monitored and limited+    - Audit trail is maintained for all operations+    """+

+        # Security settings+        self.max_execution_time = 30.0  # seconds+        self.max_memory_mb = 100+        self.allowed_capabilities = set(PluginCapability)+        self.audit_log = []++    def add_plugin_directory(self, directory: str) -> None:+        """Add directory to scan for plugins."""+        if os.path.isdir(directory):+            self.plugin_directories.add(os.path.abspath(directory))

++This module provides security sandboxing for plugin execution, ensuring+plugins cannot access sensitive data, perform unauthorized operations,+or consume excessive resources.++Security Features:+- Resource limits (memory, execution time)+- Capability enforcement+- File system access restrictions+- Network access controls+- Process isolation where possible+"""++import gc+import logging+import multiprocessing+import os+import resource+import signal+import sys+import tempfile+import threading+import time+from contextlib import contextmanager+from typing import Any, Dict, Optional++from .plugin_base import BasePlugin, PluginCapability, PluginResult, PluginSecurityContext+

+        self.start_memory = 0+        self.peak_memory = 0+        self.start_time = 0+        self.execution_time = 0+        self.monitoring = False++    def start(self):+        """Start resource monitoring."""+        self.start_memory = self._get_memory_usage()+        self.peak_memory = self.start_memory+        self.start_time = time.time()+        self.monitoring = True++    def stop(self):+        """Stop resource monitoring."""+        if self.monitoring:+            self.execution_time = time.time() - self.start_time+            self.monitoring = False++    def update_peak_memory(self):+        """Update peak memory usage."""+        if self.monitoring:+            current_memory = self._get_memory_usage()+            if current_memory > self.peak_memory:+                self.peak_memory = current_memory++    def get_stats(self) -> Dict[str, float]:+        """Get resource usage statistics."""+        return {+            "memory_start_mb": self.start_memory / (1024 * 1024),+            "memory_peak_mb": self.peak_memory / (1024 * 1024),+            "memory_used_mb": (self.peak_memory - self.start_memory) / (1024 * 1024),+            "execution_time_s": self.execution_time,+        }++    @staticmethod+    def _get_memory_usage() -> int:+        """Get current memory usage in bytes."""+        try:+            # Try to get RSS (Resident Set Size) on Unix systems+            if hasattr(resource, "RUSAGE_SELF"):+                usage = resource.getrusage(resource.RUSAGE_SELF)+                # On Linux, ru_maxrss is in KB, on BSD systems it's in bytes+                if sys.platform == "linux":+                    return usage.ru_maxrss * 1024+                else:+                    return usage.ru_maxrss+            else:+                # Fallback for systems without resource module+                import psutil+

     """Run AST security analysis on a plugin's source code before execution.@@ -78,17 +81,11 @@ class PluginImportGuard:     access to already-imported modules.     """ -    # Modules that should always be blocked-    ALWAYS_BLOCKED = {-        "ctypes",  # Load arbitrary C code

-        "subprocess": None,  # Always blocked (no capability for this)-        "os": None,  # Always blocked (contains os.system, etc.)         "socket": PluginCapability.NETWORK_ACCESS,  # Allowed with NETWORK_ACCESS     } 

++Both the AST analyzer (static analysis) and the import guard (runtime)+reference this single source of truth to ensure blocked module lists+stay in sync.+"""

+    "importlib",+    "__builtin__",+    "__builtins__",+    "sys",+    "shutil",+    "pickle",+    "shelve",+    "commands",+    "pty",+    "fcntl",+    "pwd",+    "grp",+    "signal",+    "resource",+    "pipes",+    "popen2",+    "platform",+    "os",       # os.system, os.popen, etc. — always blocked+    "pathlib",  # Path.read_text() etc. bypass sandbox file restrictions+    "io",       # io.open() bypasses sandbox restricted_open+})

-    # Modules that should never be imported-    # Note: 'os' and 'socket' are NOT blocked here:-    #   - 'os' is needed for path operations; file access is restricted by sandbox allowed_paths-    #   - 'socket' is needed for network plugins; dangerous OS functions are checked separately-    DANGEROUS_MODULES = {-        "subprocess",-        "ctypes",-        "multiprocessing",-        "importlib",-        "__builtin__",-        "__builtins__",-        "sys",-        "shutil",-        "pickle",-        "shelve",-        "commands",-        "pty",-        "fcntl",-        "pwd",-        "grp",-        "signal",-        "resource",-        "pipes",-        "popen2",