mcpower-proxy 0.0.58__py3-none-any.whl

modules/ui/confirmation.py

@@ -0,0 +1,200 @@
+"""
+User Confirmation Dialog for Security Policy Enforcement
+
+Provides simple, lightweight modal dialogs for explicit user confirmation
+when security policies require user approval for MCP operations.
+"""
+
+from datetime import datetime, timezone
+from typing import Optional
+
+from mcpower_shared.mcp_types import UserDecision
+
+from modules.logs.audit_trail import AuditTrailLogger
+from modules.logs.logger import MCPLogger
+from . import xdialog
+from .classes import ConfirmationRequest, ConfirmationResponse, UserConfirmationError, DialogOptions
+from .simple_dialog import show_explicit_user_confirmation_dialog, show_blocking_dialog
+
+
+# noinspection PyMethodMayBeStatic
+class UserConfirmationDialog:
+    """
+    Simple user confirmation dialog using tkinter messagebox
+    
+    Provides lightweight modal dialogs for explicit user approval of MCP operations
+    when security policies require confirmation at request or response stages.
+    """
+
+    def __init__(self, logger: MCPLogger, audit_logger: AuditTrailLogger):
+        self.logger = logger
+        self.audit_logger = audit_logger
+
+    def request_confirmation(self, request: ConfirmationRequest, prompt_id: str,
+                             call_type: Optional[str] = None, options: DialogOptions = None) -> ConfirmationResponse:
+        """
+        Display a confirmation dialog and wait for the user decision
+        
+        Args:
+            request: Confirmation request with all necessary context
+            call_type: Optional call type from inspect decision ("read", "write")
+            options: Optional dialog options for controlling button visibility
+            prompt_id: Prompt ID for audit trail grouping (mandatory for tool calls)
+            
+        Returns:
+            ConfirmationResponse with user decision
+            
+        Raises:
+            UserConfirmationError: If a user denies or the dialog fails
+        """
+        if options is None:
+            options = DialogOptions()
+        self.logger.info(f"Requesting user confirmation for "
+                         f"{'request' if request.is_request else 'response'} "
+                         f"operation on tool '{request.tool_name}' (event: {request.event_id})")
+
+        # AUDIT: Log user interaction
+        self.audit_logger.log_event(
+            "user_interaction",
+            {
+                "type": "dialog",
+                "interaction": "explicit user confirmation"
+            },
+            event_id=request.event_id,
+            prompt_id=prompt_id
+        )
+
+        result = show_explicit_user_confirmation_dialog(request, options, self.logger)
+        direction = "request" if request.is_request else "response"
+
+        # Convert dialog result to UserDecision enum
+        match result:
+            case xdialog.YES:
+                user_decision = UserDecision.ALLOW
+            case xdialog.YES_ALWAYS:
+                user_decision = UserDecision.ALWAYS_ALLOW
+            case xdialog.NO_ALWAYS:
+                user_decision = UserDecision.ALWAYS_BLOCK
+            case _:  # NO or any other result
+                user_decision = UserDecision.BLOCK
+
+        response = ConfirmationResponse(
+            user_decision=user_decision,
+            timestamp=datetime.now(timezone.utc),
+            event_id=request.event_id,
+            direction=direction,
+            call_type=call_type
+        )
+        self._log_confirmation_decision(request, response)
+
+        # AUDIT: Log user interaction result
+        self.audit_logger.log_event(
+            "user_interaction_result",
+            {
+                "decision": user_decision.value
+            },
+            event_id=request.event_id,
+            prompt_id=prompt_id
+        )
+
+        # Process user decision
+        if user_decision in (UserDecision.BLOCK, UserDecision.ALWAYS_BLOCK):
+            # User denied confirmation
+            raise UserConfirmationError(
+                f"User denied {'request' if request.is_request else 'response'} operation "
+                f"for tool '{request.tool_name}'",
+                event_id=request.event_id,
+                is_request=request.is_request,
+                tool_name=request.tool_name
+            )
+
+        # User approved
+        return response
+
+    def request_blocking_confirmation(self, request: ConfirmationRequest, prompt_id: str,
+                                      call_type: Optional[str] = None) -> ConfirmationResponse:
+        """
+        Display a blocking dialog and wait for the user decision
+        Shows "Block" vs "Allow Anyway" options for policy-blocked requests
+        
+        Args:
+            request: Confirmation request with all necessary context
+            prompt_id: Prompt ID for audit trail grouping (mandatory for tool calls)
+            call_type: Optional call type from inspect decision ("read", "write")
+            
+        Returns:
+            ConfirmationResponse with user decision
+            
+        Raises:
+            UserConfirmationError: If user chooses to block or dialog fails
+        """
+        self.logger.info(f"Requesting user blocking confirmation for "
+                         f"{'request' if request.is_request else 'response'} "
+                         f"operation on tool '{request.tool_name}' (event: {request.event_id})")
+
+        # AUDIT: Log user interaction
+        self.audit_logger.log_event(
+            "user_interaction",
+            {
+                "type": "dialog",
+                "interaction": "block recommendation"
+            },
+            event_id=request.event_id,
+            prompt_id=prompt_id
+        )
+
+        result = show_blocking_dialog(request, self.logger)
+        direction = "request" if request.is_request else "response"
+
+        # Convert dialog result to UserDecision enum
+        match result:
+            case xdialog.YES:  # Allow Anyway
+                user_decision = UserDecision.ALLOW
+            case _:  # NO (Block) or any other result
+                user_decision = UserDecision.BLOCK
+
+        response = ConfirmationResponse(
+            user_decision=user_decision,
+            timestamp=datetime.now(timezone.utc),
+            event_id=request.event_id,
+            direction=direction,
+            call_type=call_type
+        )
+        self._log_confirmation_decision(request, response)
+
+        # AUDIT: Log user interaction result
+        self.audit_logger.log_event(
+            "user_interaction_result",
+            {
+                "decision": user_decision.value
+            },
+            event_id=request.event_id,
+            prompt_id=prompt_id
+        )
+
+        # Process user decision - only allow if user explicitly chose "Allow Anyway"
+        if user_decision == UserDecision.BLOCK:
+            # User chose to block
+            raise UserConfirmationError(
+                f"User blocked {'request' if request.is_request else 'response'} operation "
+                f"for tool '{request.tool_name}'",
+                event_id=request.event_id,
+                is_request=request.is_request,
+                tool_name=request.tool_name
+            )
+
+        # User chose "Allow Anyway"
+        return response
+
+    def _log_confirmation_decision(self, request: ConfirmationRequest, response: ConfirmationResponse):
+        """Log user confirmation decision for audit trail"""
+        self.logger.debug(
+            f"User confirmation decision: "
+            f"event_id={response.event_id}, "
+            f"direction={response.direction}, "
+            f"tool={request.tool_name}, "
+            f"user_decision={response.user_decision.value}, "
+            f"call_type={response.call_type}, "
+            f"timed_out={response.timed_out}, "
+            f"timestamp={response.timestamp.isoformat()}"
+        )

modules/ui/simple_dialog.py

@@ -0,0 +1,104 @@
+"""
+Simple, lightweight confirmation dialog using native OS dialogs
+
+This provides cross-platform native dialogs
+"""
+
+from modules.logs.logger import MCPLogger
+
+from . import xdialog
+from .classes import ConfirmationRequest, DialogOptions
+
+
+def show_explicit_user_confirmation_dialog(request: ConfirmationRequest, options: DialogOptions,
+                                           logger: MCPLogger) -> int:
+    """
+    Show a native OS confirmation dialog using xdialog
+
+    Returns:
+        int: xdialog constant (YES, NO, YES_ALWAYS, NO_ALWAYS)
+    """
+    message = (f"Server: {request.server_name}"
+               f"\nTool: {request.tool_name}"
+               f"\n\nPolicy Alert ({request.severity.title()}):"
+               f"\n{request.policy_reasons[0]}")
+
+    try:
+        # Build custom button array: Block, Always Block (optional), Allow, Always Allow (optional)
+        buttons = ["Block"]
+
+        if options.show_always_block:
+            buttons.append("Always Block")
+
+        buttons.append("Allow")
+
+        if options.show_always_allow:
+            buttons.append("Always Allow")
+
+        # Use generic dialog with Block/Allow buttons
+        result_index = xdialog.generic_dialog(
+            title="MCPower Security Confirmation Required",
+            message=message,
+            buttons=buttons,
+            default_button=buttons.index("Allow"),  # Default to "Allow"
+            icon=xdialog.ICON_WARNING
+        )
+
+        # Map button indices back to xdialog constants for compatibility
+        # Button order: Block, [Always Block], Allow, [Always Allow]
+        if result_index == 0:
+            return xdialog.NO  # Block -> NO
+        elif options.show_always_block and result_index == 1:
+            return xdialog.NO_ALWAYS  # Always Block -> NO_ALWAYS
+        elif not options.show_always_block and result_index == 1:
+            return xdialog.YES  # Allow -> YES (when no Always Block)
+        elif options.show_always_block and result_index == 2:
+            return xdialog.YES  # Allow -> YES (when Always Block is present)
+        elif not options.show_always_block and result_index == 2:
+            return xdialog.YES_ALWAYS  # Always Allow -> YES_ALWAYS (when no Always Block)
+        elif options.show_always_block and result_index == 3:
+            return xdialog.YES_ALWAYS  # Always Allow -> YES_ALWAYS (when Always Block is present)
+        else:
+            raise Exception(f"Unexpected result index {result_index}")
+
+    except Exception as e:
+        logger.error(f"Native dialog error: {e}")
+        raise e
+
+
+def show_blocking_dialog(request: ConfirmationRequest, logger: MCPLogger) -> int:
+    """
+    Show a blocking dialog with red error styling and "Block"/"Allow Anyway" buttons
+    
+    Returns:
+        int: xdialog constant (YES=Allow Anyway, NO=Block)
+    """
+    message = (f"Server: {request.server_name}"
+               f"\nTool: {request.tool_name}"
+               f"\n\nPolicy Alert ({request.severity.title()}):"
+               f"\n{request.policy_reasons[0]}")
+
+    try:
+        # Build button array: Block (default), Allow Anyway
+        buttons = ["Block", "Allow Anyway"]
+
+        # Use generic dialog with error icon and Block as default
+        result_index = xdialog.generic_dialog(
+            title="MCPower Security Request Blocked",
+            message=message,
+            buttons=buttons,
+            default_button=0,  # Default to "Block" button (first button)
+            icon=xdialog.ICON_ERROR  # Red error icon
+        )
+
+        # Map button indices to xdialog constants
+        if result_index == 0:
+            return xdialog.NO  # Block -> NO
+        elif result_index == 1:
+            return xdialog.YES  # Allow Anyway -> YES
+        else:
+            raise Exception(f"Unexpected result index {result_index}")
+
+    except Exception as e:
+        logger.error(f"Blocking dialog error: {e}")
+        raise e

modules/ui/xdialog/__init__.py

@@ -0,0 +1,249 @@
+import platform
+import subprocess
+
+from .constants import *
+from typing import Iterable, Union, Tuple, Optional, Literal, overload
+
+__all__ = [
+    "open_file", "save_file", "directory",
+    "info", "warning", "error",
+    "yesno", "yesno_always", "yesnocancel", "retrycancel", "okcancel",
+    "generic_dialog",
+    "YES", "NO", "CANCEL", "RETRY", "OK", "YES_ALWAYS", "NO_ALWAYS",
+    "ICON_QUESTION", "ICON_WARNING", "ICON_ERROR", "ICON_INFO"
+]
+
+SYSTEM = platform.system()
+
+# Find the best dialog for this platform. Default to tkinter.
+# Using import keyword instead of __import__ for extra compatibility.
+def get_dialogs():
+    if SYSTEM == 'Windows':
+        from . import windows_dialogs
+        return windows_dialogs
+    elif SYSTEM == "Darwin":
+        from . import mac_dialogs
+        return mac_dialogs
+    else:
+        def cmd_exists(cmd):
+            proc = subprocess.Popen(('which', cmd), stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, shell=False)
+            proc.communicate()
+            return not proc.returncode
+
+        if cmd_exists('yad'):
+            from . import yad_dialogs
+            return yad_dialogs
+        if cmd_exists('zenity'):
+            from . import zenity_dialogs
+            return zenity_dialogs
+
+    try:
+        from . import tk_dialogs
+        return tk_dialogs
+    except ModuleNotFoundError: pass
+
+    raise ModuleNotFoundError('No dialog type is supported on this machine. Install tkinter to guarantee dialogs.')
+
+
+
+dialogs = get_dialogs()
+
+@overload
+def open_file(title: Optional[str] = None, filetypes: Iterable[Tuple[str, str]] = [("All Files", "*")], multiple: Literal[False] = False) -> str: ...
+@overload
+def open_file(title: Optional[str] = None, filetypes: Iterable[Tuple[str, str]] = [("All Files", "*")], multiple: Literal[True] = True) -> Iterable[str]: ...
+
+def open_file(title: Optional[str] = None, filetypes: Iterable[Tuple[str, str]] = [("All Files", "*")], multiple: bool = False) -> Union[str, Iterable[str]]:
+    '''Shows a dialog box for selecting one or more files to be opened.
+
+    Arguments:
+        title: Text to show on the header of the dialog box.
+            Omitting it has system-dependent results.
+
+        filetypes: A list of tuples specifying which filetypes to show.
+            The first string is a readable name of that filetype, and
+            the second string is one or more glob (e.g., * or *.txt) extension.
+
+            Each glob in the second string is separated by spaces.
+
+            Each tuple will normally appear in a dropdown of file types to select from.
+            If this argument is not specified, all file types are visible.
+
+            MacOS will ignore the first string in each tuple (as it doesn't
+            display it anywhere), and will instead enable selection of all
+            file extensions provided.
+
+        multiple: If False (default), only one file may be selected. If True, multiple files may be selected.
+
+    Returns:
+        If `multiple` is True, an iterable of selected files or an empty iterable.
+        If `multiple` is False, the file that was selected or an empty string.
+    '''
+    return dialogs.open_file(title, filetypes, multiple)
+
+def save_file(title: Optional[str] = None, filetypes: Iterable[Tuple[str, str]] = [("All Files", "*")]) -> str:
+    '''Shows a dialog box for selecting one or more files to be opened.
+
+    Arguments:
+        title: Text to show on the header of the dialog box.
+            Omitting it has system-dependent results.
+
+        filetypes: A list of tuples specifying which filetypes to show.
+            The first string is a readable name of that filetype, and
+            the second string is one or more glob (e.g., * or *.txt) expression.
+
+            Each glob in the second string is separated by spaces.
+
+            Each tuple will appear in a dropdown of file types to select from.
+            If this argument is not specified, all file types are visible.
+
+            MacOS does not support this option, but will instead use the first
+            tuple's glob to populate the default name.
+
+    Returns:
+        The file that was selected or an empty string.
+    '''
+    return dialogs.save_file(title, filetypes)
+
+def directory(title: Optional[str] = None) -> str:
+    '''Shows a dialog box for selecting a directory. The directory must exist to be selected.
+
+    Arguments:
+        title: Text to show on the header of the dialog box.
+            Omitting it has system-dependent results.
+
+    Returns:
+        The directory that was selected or an empty string.
+    '''
+    return dialogs.directory(title)
+
+def info(title: Optional[str] = None, message: str = '') -> None:
+    '''Shows an info dialog box.
+
+    Arguments:
+        title: Text to show on the header of the dialog box.
+            Omitting it has system-dependent results.
+
+        message: Text to show in the middle of the dialog box.
+    '''
+    dialogs.info(title, message)
+
+def warning(title: Optional[str] = None, message: str = '') -> None:
+    '''Shows a warning dialog box.
+
+    Arguments:
+        title: Text to show on the header of the dialog box.
+            Omitting it has system-dependent results.
+
+        message: Text to show in the middle of the dialog box.
+    '''
+    dialogs.warning(title, message)
+
+def error(title: Optional[str] = None, message: str = '') -> None:
+    '''Shows an error dialog box.
+
+    Arguments:
+        title: Text to show on the header of the dialog box.
+            Omitting it has system-dependent results.
+
+        message: Text to show in the middle of the dialog box.
+    '''
+    dialogs.error(title, message)
+
+def yesno(title: Optional[str] = None, message: str = '') -> int:
+    '''Shows a question dialog box with the buttons "Yes" and "No".
+
+    Arguments:
+        title: Text to show on the header of the dialog box.
+            Omitting it has system-dependent results.
+
+        message: Text to show in the middle of the dialog box.
+
+    Returns:
+        `xdialog.YES` or `xdialog.NO`. Closing the box results in `xdialog.NO`.
+    '''
+    return dialogs.yesno(title, message)
+
+def yesno_always(title: Optional[str] = None, message: str = '', yes_always: bool = False, no_always: bool = False) -> int:
+    '''Shows a question dialog box with Yes/No and optional Always buttons.
+
+    Arguments:
+        title: Text to show on the header of the dialog box.
+            Omitting it has system-dependent results.
+
+        message: Text to show in the middle of the dialog box.
+        
+        yes_always: If True, shows "Yes Always" button.
+        
+        no_always: If True, shows "No Always" button.
+
+    Returns:
+        `xdialog.YES`, `xdialog.NO`, `xdialog.YES_ALWAYS`, or `xdialog.NO_ALWAYS`.
+        Button order: No, No Always (if enabled), Yes, Yes Always (if enabled).
+    '''
+    return dialogs.yesno_always(title, message, yes_always, no_always)
+
+def yesnocancel(title: Optional[str] = None, message: str = '') -> int:
+    '''Shows a question dialog box with the buttons "Yes", "No", and "Cancel".
+
+    Arguments:
+        title: Text to show on the header of the dialog box.
+            Omitting it has system-dependent results.
+
+        message: Text to show in the middle of the dialog box.
+
+    Returns:
+        `xdialog.YES`, `xdialog.NO`, or `xdialog.CANCEL`. Closing the box results in `xdialog.CANCEL`.
+    '''
+    return dialogs.yesnocancel(title, message)
+
+def retrycancel(title: Optional[str] = None, message: str = '') -> int:
+    '''Shows a question dialog box with the buttons "Retry" and "Cancel".
+
+    Arguments:
+        title: Text to show on the header of the dialog box.
+            Omitting it has system-dependent results.
+
+        message: Text to show in the middle of the dialog box.
+
+    Returns:
+        `xdialog.RETRY` or `xdialog.CANCEL`. Closing the box results in `xdialog.CANCEL`.
+    '''
+    return dialogs.retrycancel(title, message)
+
+def okcancel(title: Optional[str] = None, message: str = '') -> int:
+    '''Shows a question dialog box with the buttons "Ok" and "Cancel".
+
+    Arguments:
+        title: Text to show on the header of the dialog box.
+            Omitting it has system-dependent results.
+
+        message: Text to show in the middle of the dialog box.
+
+    Returns:
+        `xdialog.OK` or `xdialog.CANCEL`. Closing the box results in `xdialog.CANCEL`.
+    '''
+    return dialogs.okcancel(title, message)
+
+def generic_dialog(title: str, message: str, buttons: list[str], default_button: int, icon: str) -> int:
+    '''Shows a generic dialog box with custom buttons and icon.
+
+    Arguments:
+        title: Text to show on the header of the dialog box.
+
+        message: Text to show in the middle of the dialog box.
+
+        buttons: List of button text strings to display.
+
+        default_button: Index of default button (0-based). Used when dialog is dismissed.
+
+        icon: Icon type to display. Use ICON_QUESTION, ICON_WARNING, ICON_ERROR, or ICON_INFO.
+
+    Returns:
+        Index of clicked button (0-based). If dialog is dismissed, returns default_button.
+        
+    Raises:
+        NotImplementedError: On platforms that don't support custom buttons (Zenity, Tkinter).
+        ValueError: If parameters are invalid (icon not supported, buttons empty, default_button out of range).
+    '''
+    return dialogs.generic_dialog(title, message, buttons, default_button, icon)

modules/ui/xdialog/constants.py

@@ -0,0 +1,13 @@
+YES = 0
+RETRY = 0
+OK = 0
+NO = 1
+CANCEL = 2
+YES_ALWAYS = 3
+NO_ALWAYS = 4
+
+# Icon constants for generic_dialog
+ICON_QUESTION = "question"
+ICON_WARNING = "warning"
+ICON_ERROR = "error"
+ICON_INFO = "info"