mcpower-proxy 0.0.58__py3-none-any.whl

modules/ui/xdialog/zenity_dialogs.py

@@ -0,0 +1,156 @@
+import subprocess
+from os.path import isfile
+from typing import Tuple
+
+from .constants import *
+
+def clean(txt: str):
+    return txt\
+        .replace("\\", "\\\\")\
+        .replace("$", "\\$")\
+        .replace("!", "\\!")\
+        .replace("*", "\\*")\
+        .replace("?", "\\?")\
+        .replace("&", "&")\
+        .replace("|", "|")\
+        .replace("<", "&lt;")\
+        .replace(">", "&gt;")\
+        .replace("(", "\\(")\
+        .replace(")", "\\)")\
+        .replace("[", "\\[")\
+        .replace("]", "\\]")\
+        .replace("{", "\\{")\
+        .replace("}", "\\}")\
+
+def zenity(typ, filetypes=None, **kwargs) -> Tuple[int, str]:
+    # Build args based on keywords
+    args = ['zenity', '--'+typ]
+    for k, v in kwargs.items():
+        if v is True:
+            args.append(f'--{k.replace("_", "-").strip("-")}')
+        elif isinstance(v, str):
+            cv = clean(v) if k != "title" else v
+            args.append(f'--{k.replace("_", "-").strip("-")}={cv}')
+
+    # Build filetypes specially if specified
+    if filetypes:
+        for name, globs in filetypes:
+            if name:
+                globlist = globs.split()
+                args.append(f'--file-filter={name.replace("|", "")} ({", ".join(t for t in globlist)})|{globs}')
+
+    proc = subprocess.Popen(
+        args,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.DEVNULL,
+        shell=False
+    )
+    stdout, _ = proc.communicate()
+
+    return (proc.returncode, stdout.decode('utf-8').strip())
+
+
+def open_file(title, filetypes, multiple=False):
+    # Zenity is strange and will let you select folders for some reason in some cases. So we filter those out.
+    if multiple:
+        files = zenity('file-selection', title=title, filetypes=filetypes, multiple=True, separator="\n")[1].splitlines()
+        return list(filter(isfile, files))
+    else:
+        file = zenity('file-selection', title=title, filetypes=filetypes)[1]
+        if file and isfile(file):
+            return file
+        else:
+            return ''
+
+def save_file(title, filetypes):
+    return zenity('file-selection', title=title, filetypes=filetypes, save=True)[1]
+
+def directory(title):
+    return zenity("file-selection", title=title, directory=True)[1]
+
+def info(title, message):
+    zenity("info", title=title, text=message)
+
+def warning(title, message):
+    zenity("warning", title=title, text=message)
+
+def error(title, message):
+    zenity("error", title=title, text=message)
+
+def yesno(title, message):
+    return zenity("question", title=title, text=message)[0]
+
+def yesno_always(title, message, yes_always=False, no_always=False):
+    """
+    Enhanced yes/no dialog with optional always buttons
+    Button order: No, No Always (if enabled), Yes, Yes Always (if enabled)
+    
+    Note: Zenity has limited custom button support, so we fall back to yesno
+    for now. Full implementation would require GTK+ dialog creation.
+    """
+    # TODO: Implement custom Zenity dialog with proper button layout
+    # For now, fall back to standard yesno dialog
+    return yesno(title, message)
+
+def yesnocancel(title, message):
+    r = zenity(
+        "question",
+        title=title,
+        text=message,
+        extra_button="No",
+        cancel_label="Cancel"
+    )
+
+    if r[1]:
+        return NO
+    elif r[0]:
+        return CANCEL
+    else:
+        return YES
+
+def retrycancel(title, message):
+    r = zenity(
+        "question",
+        title=(title or ""),
+        text=message,
+        ok_label="Retry",
+        cancel_label="Cancel"
+    )[0]
+
+    if r:
+        return CANCEL
+    else:
+        return RETRY
+
+def okcancel(title, message):
+    r = zenity(
+        "question",
+        title=title,
+        text=message,
+        ok_label="Ok",
+        cancel_label="Cancel"
+    )[0]
+
+    if r:
+        return CANCEL
+    else:
+        return OK
+
+def generic_dialog(title, message, buttons, default_button, icon):
+    """
+    Generic dialog with custom buttons and icon
+    
+    Args:
+        title (str): Dialog title
+        message (str): Dialog message
+        buttons (list): List of button text strings
+        default_button (int): Index of default button (0-based)
+        icon (str): Icon type (ICON_QUESTION, ICON_WARNING, ICON_ERROR, ICON_INFO)
+    
+    Returns:
+        int: Index of clicked button (0-based)
+    
+    Raises:
+        NotImplementedError: Zenity has limited custom button support
+    """
+    raise NotImplementedError("generic_dialog is not supported on Zenity - custom buttons are not fully supported")

modules/utils/__init__.py

@@ -0,0 +1 @@
+# Utilities package

modules/utils/cli.py

@@ -0,0 +1,46 @@
+"""
+CLI utilities for MCPower Proxy
+"""
+import argparse
+
+
+def parse_args():
+    """Parse command line arguments"""
+    parser = argparse.ArgumentParser(
+        description="MCPower - Transparent 1:1 MCP Wrapper with security enforcement",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Single server config
+  %(prog)s --wrapped-config '{"command": "npx", "args": ["@modelcontextprotocol/server-filesystem", "/path/to/allowed-dir"]}'
+  
+  # Named server config  
+  %(prog)s --wrapped-config '{"my-server": {"command": "python", "args": ["server.py"], "env": {"DEBUG": "1"}}}'
+  
+  # MCPConfig format
+  %(prog)s --wrapped-config '{"mcpServers": {"default": {"command": "node", "args": ["server.js"]}}}'
+  
+  # With custom name
+  %(prog)s --wrapped-config '{"command": "node", "args": ["server.js"]}' --name MyWrapper
+
+Reference Links:
+  • FastMCP Proxy: https://gofastmcp.com/servers/proxy
+  • FastMCP Middleware: https://gofastmcp.com/servers/middleware  
+  • MCP Official: https://modelcontextprotocol.io
+  • Claude MCP Config: https://docs.anthropic.com/en/docs/claude-code/mcp
+        """
+    )
+
+    parser.add_argument(
+        '--wrapped-config',
+        required=True,
+        help='JSON/JSONC configuration for the wrapped MCP server (FastMCP will handle validation)'
+    )
+
+    parser.add_argument(
+        '--name',
+        default='MCPWrapper',
+        help='Name for the wrapper MCP server (default: MCPWrapper)'
+    )
+
+    return parser.parse_args()

modules/utils/config.py

@@ -0,0 +1,193 @@
+"""
+Centralized configuration loader with caching
+Reads from ~/.mcpower/config file
+"""
+from pathlib import Path
+from typing import Dict, Optional
+
+from modules.logs.logger import MCPLogger
+
+
+def load_default_config() -> Dict[str, str]:
+    """Load default configuration from embedded constants"""
+    try:
+        config_data = {
+            "API_URL": "https://api.mcpower.tech",
+            "DEBUG": "0"
+        }
+        return config_data
+    except Exception as e:
+        raise RuntimeError(f"FATAL: Failed to load default config: {e}")
+
+
+# Load default configuration from shared file
+default_config = load_default_config()
+
+
+class ConfigManager:
+    """Singleton configuration manager with caching and file monitoring"""
+
+    _instance: Optional['ConfigManager'] = None
+    _config: Optional[Dict[str, str]] = None
+    _observer = None  # Will be watchdog Observer if available
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    @property
+    def config(self) -> Dict[str, str]:
+        """Get cached config, loading if necessary"""
+        if self._config is None:
+            self._config = ConfigManager._load_config()
+        return self._config
+
+    @staticmethod
+    def _load_config() -> Dict[str, str]:
+        """Load config from ~/.mcpower/config file"""
+        config_path = ConfigManager.get_config_path()
+
+        # Create default config if it doesn't exist
+        if not config_path.exists():
+            ConfigManager._create_default_config(config_path)
+
+        content = config_path.read_text()
+        # Parse key=value configuration content
+        new_config = {}
+        for line in content.split('\n'):
+            line = line.strip()
+            if line and '=' in line and not line.startswith('#'):
+                key, value = line.split('=', 1)
+                new_config[key.strip()] = value.strip()
+        return new_config
+
+    @classmethod
+    def get_config_path(cls):
+        return ConfigManager.get_user_config_dir() / 'config'
+
+    @staticmethod
+    def _create_default_config(config_path: Path):
+        """Create default config file"""
+        config_path.parent.mkdir(exist_ok=True)
+
+        # Convert to key=value format
+        config_lines = ['# MCPower Configuration']
+        for key, value in default_config.items():
+            config_lines.append(f'{key}={value}')
+
+        config_path.write_text('\n'.join(config_lines) + '\n')
+
+    @staticmethod
+    def get_user_config_dir() -> Path:
+        """Get user config directory (~/.mcpower)"""
+        return Path.home() / '.mcpower'
+
+    def get(self, key: str, default: str = None) -> str:
+        """Get config value with optional default"""
+        return self.config.get(key, default)
+
+    def reload(self, logger: MCPLogger):
+        """Force reload config from file"""
+        self._config = None
+        logger.debug("Config reloaded from ~/.mcpower/config")
+
+    def start_monitoring(self, logger: MCPLogger):
+        """Start file system monitoring using watchdog (event-driven)"""
+        try:
+            # Try to import watchdog - graceful fallback if not available
+            from watchdog.observers import Observer
+            from watchdog.events import FileSystemEventHandler
+
+            if self._observer is not None:
+                return  # Already monitoring
+
+            class ConfigFileHandler(FileSystemEventHandler):
+                def __init__(self, config_manager):
+                    self.config_manager = config_manager
+                    self.config_path = str(config_manager.get_user_config_dir() / 'config')
+
+                def on_modified(self, event):
+                    if not event.is_directory and event.src_path == self.config_path:
+                        logger.debug("Config file changed (event), reloading...")
+                        self.config_manager.reload(logger)
+
+                def on_created(self, event):
+                    if not event.is_directory and event.src_path == self.config_path:
+                        logger.debug("Config file created (event), reloading...")
+                        self.config_manager.reload(logger)
+
+            self._observer = Observer()
+            event_handler = ConfigFileHandler(self)
+            watch_dir = str(self.get_user_config_dir())
+
+            self._observer.schedule(event_handler, watch_dir, recursive=False)
+            self._observer.start()
+            logger.debug("Started monitoring ~/.mcpower/config (event-driven)")
+
+        except ImportError:
+            logger.warning("watchdog not available, install with: pip install watchdog")
+            logger.warning("Falling back to manual reload - call config.reload() when needed")
+        except Exception as e:
+            logger.warning(f"Failed to start file monitoring: {e}")
+            logger.warning("Falling back to manual reload - call config.reload() when needed")
+
+    def stop_monitoring(self, logger: MCPLogger):
+        """Stop file system monitoring"""
+        if self._observer is not None:
+            self._observer.stop()
+            self._observer.join()
+            self._observer = None
+            logger.debug("Stopped monitoring ~/.mcpower/config")
+
+
+# Singleton instance
+config = ConfigManager()
+
+
+# Convenience functions
+
+def resolve_config_path(path_value: str) -> str:
+    """
+    Resolve a configuration path value, handling ./ as relative to config folder
+    
+    Args:
+        path_value: The path value from config (e.g., './log.txt', '/tmp/log.txt', 'log.txt')
+    
+    Returns:
+        Resolved absolute path string
+    """
+    if path_value.startswith('./'):
+        config_dir = ConfigManager.get_user_config_dir()
+        return str(config_dir / path_value[2:])  # Remove ./ prefix
+
+    return path_value
+
+
+def get_api_url() -> str:
+    """Get default API URL"""
+    key = 'API_URL'
+    return config.get(key, default_config.get(key))
+
+
+def get_log_path() -> str:
+    """Get default log file path """
+    return str(ConfigManager.get_user_config_dir() / 'mcp-wrapper.log')
+
+
+def get_audit_trail_path() -> str:
+    """Get audit trail log file path (same directory as main log)"""
+    return str(ConfigManager.get_user_config_dir() / 'audit_trail.log')
+
+
+def is_debug_mode() -> bool:
+    """Get debug mode setting"""
+    key = 'DEBUG'
+    value = str(config.get(key, default_config.get(key)))
+    return value.lower() in ('true', '1', 'yes', 'on')
+
+
+def get_user_id(logger: MCPLogger) -> str:
+    """Get or create user ID from ~/.mcpower/uid (never fails)"""
+    from modules.utils.ids import get_or_create_user_id
+    return get_or_create_user_id(logger)

modules/utils/copy.py

@@ -0,0 +1,36 @@
+import copy
+from typing import TypeVar, Dict, Any
+
+T = TypeVar('T')
+
+
+def safe_copy(obj: T, update_dict: Dict[str, Any] = None) -> T:
+    """
+    Safely copy an object (Pydantic model or regular object) with optional updates.
+
+    Args:
+        obj: The object to copy (can be Pydantic model or regular object)
+        update_dict: Optional dictionary of field updates to apply
+
+    Returns:
+        A copy of the object with updates applied
+    """
+    if update_dict is None:
+        update_dict = {}
+
+    # Try Pydantic model_copy first (v2)
+    if hasattr(obj, 'model_copy'):
+        return obj.model_copy(update=update_dict)
+
+    # Try generic copy method (v1 or custom objects)
+    elif hasattr(obj, 'copy'):
+        return obj.copy(update=update_dict)
+
+    # Fallback to manual copying for regular objects
+    else:
+        # Use deepcopy to match original behavior and ensure complete isolation
+        new_obj = copy.deepcopy(obj)
+        # Apply updates
+        for key, value in update_dict.items():
+            setattr(new_obj, key, value)
+        return new_obj

modules/utils/ids.py

@@ -0,0 +1,160 @@
+"""
+Utilities for generating event IDs, session IDs, app UIDs, and timing helpers
+"""
+import os
+import time
+import uuid
+from pathlib import Path
+from typing import Optional
+
+# Process-wide session ID cache
+_session_id: Optional[str] = None
+
+
+def generate_event_id() -> str:
+    """
+    Generate unique event ID for MCP operations
+    
+    Returns:
+        Unique event ID string
+    """
+    timestamp = int(time.time() * 1000)  # milliseconds
+    unique_part = str(uuid.uuid4())[:8]
+    return f"{timestamp}-{unique_part}"
+
+
+def get_session_id() -> str:
+    """
+    Get session ID for the current process. Returns the same value for all calls
+    within the same Python process instance.
+    
+    Returns:
+        Process-wide session ID string
+    """
+    global _session_id
+    if _session_id is None:
+        _session_id = str(uuid.uuid4())
+    return _session_id
+
+
+def is_valid_uuid(uuid_string: str) -> bool:
+    """
+    Validate if a string is a valid UUID
+    
+    Args:
+        uuid_string: String to validate
+        
+    Returns:
+        True if valid UUID, False otherwise
+    """
+    try:
+        uuid.UUID(uuid_string)
+        return True
+    except ValueError:
+        return False
+
+
+def _atomic_write_uuid(file_path: Path, new_uuid: str) -> bool:
+    """
+    Attempt atomic write of UUID to file using O_CREAT | O_EXCL.
+    Returns True if write succeeded, False if file already exists.
+    
+    Args:
+        file_path: Path to write UUID
+        new_uuid: UUID string to write
+        
+    Returns:
+        True if write succeeded, False if file exists
+    """
+    try:
+        fd = os.open(str(file_path), os.O_CREAT | os.O_EXCL | os.O_WRONLY, 0o600)
+        try:
+            os.write(fd, new_uuid.encode('utf-8'))
+        finally:
+            os.close(fd)
+        return True
+    except FileExistsError:
+        return False
+
+
+def _get_or_create_uuid(uid_path: Path, logger, id_type: str) -> str:
+    """
+    Get or create UUID at specified path with race safety.
+    Common logic shared by user ID and app UID generation.
+    
+    Args:
+        uid_path: Path to UUID file
+        logger: Logger instance
+        id_type: Description for logging (e.g., "user ID", "app UID")
+        
+    Returns:
+        UUID string
+    """
+    uid_path.parent.mkdir(parents=True, exist_ok=True)
+    
+    max_attempts = 3
+    for attempt in range(max_attempts):
+        if uid_path.exists():
+            try:
+                existing_uid = uid_path.read_text().strip()
+                if is_valid_uuid(existing_uid):
+                    return existing_uid
+                logger.warning(f"Invalid UUID in {uid_path}, regenerating (attempt {attempt + 1}/{max_attempts})")
+                uid_path.unlink()
+            except Exception as e:
+                logger.warning(f"Failed to read {uid_path}: {e} (attempt {attempt + 1}/{max_attempts})")
+                if attempt < max_attempts - 1:
+                    time.sleep(0.1 * (2 ** attempt))
+                    continue
+                raise
+        
+        new_uid = str(uuid.uuid4())
+        
+        if _atomic_write_uuid(uid_path, new_uid):
+            logger.info(f"Generated {id_type}: {new_uid}")
+            return new_uid
+        
+        logger.debug(f"{id_type.title()} file created by another process, reading (attempt {attempt + 1}/{max_attempts})")
+        if attempt < max_attempts - 1:
+            time.sleep(0.05)
+    
+    raise RuntimeError(f"Failed to get or create {id_type} after {max_attempts} attempts")
+
+
+def get_or_create_user_id(logger) -> str:
+    """
+    Get or create machine-wide user ID from ~/.mcpower/uid
+    Race-safe: multiple concurrent processes will converge on single ID
+    
+    Args:
+        logger: Logger instance for messages
+        
+    Returns:
+        User ID string
+    """
+    uid_path = Path.home() / ".mcpower" / "uid"
+    return _get_or_create_uuid(uid_path, logger, "user ID")
+
+
+def read_app_uid(logger, project_folder_path: str) -> str:
+    """
+    Get or create app UID from project folder's .mcpower/app_uid file
+    Race-safe: multiple concurrent processes will converge on single ID
+
+    Args:
+        logger: Logger instance for messages
+        project_folder_path: Path to the project folder
+
+    Returns:
+        App UID string
+    """
+    project_path = Path(project_folder_path)
+
+    # Check if path already contains .mcpower (forced/default case)
+    if ".mcpower" in project_path.parts:
+        uid_path = project_path / "app_uid"
+    else:
+        # Project-specific case
+        uid_path = project_path / ".mcpower" / "app_uid"
+    
+    return _get_or_create_uuid(uid_path, logger, "app UID")