mcpower-proxy 0.0.67__py3-none-any.whl → 0.0.77__py3-none-any.whl

ide_tools/common/hooks/utils.py

@@ -0,0 +1,286 @@
+"""
+Common utilities for IDE hooks - IDE-agnostic
+"""
+
+import json
+import re
+from collections import Counter
+from typing import Dict, Any, List, Callable, Optional
+
+from mcpower_shared.mcp_types import create_policy_request, create_policy_response, AgentContext, EnvironmentContext, \
+    ServerRef, ToolRef
+from modules.apis.security_policy import SecurityPolicyClient
+from modules.decision_handler import DecisionHandler
+from modules.logs.audit_trail import AuditTrailLogger
+from modules.logs.logger import MCPLogger
+from modules.redaction import redact
+from modules.utils.json import safe_json_dumps
+from wrapper.__version__ import __version__
+
+
+def create_validator(
+        required_fields: Dict[str, type],
+        optional_fields: Optional[Dict[str, type]] = None
+) -> Callable[[str], Dict[str, Any]]:
+    """
+    Factory for input validators
+    
+    Args:
+        required_fields: Dict mapping field names to their expected types
+        optional_fields: Dict mapping optional field names to their expected types
+        
+    Returns:
+        Validator function that parses and validates input
+    """
+
+    def parse_and_validate_input(stdin_input: str) -> Dict[str, Any]:
+        try:
+            if not stdin_input.strip():
+                raise ValueError("No input provided")
+            input_data = json.loads(stdin_input)
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Failed to parse input: {e}")
+
+        for field, expected_type in required_fields.items():
+            if field not in input_data:
+                raise ValueError(f"No {field} provided in input")
+            if not isinstance(input_data[field], expected_type):
+                raise ValueError(f"{field} must be a {expected_type.__name__}")
+
+        if optional_fields:
+            for field, expected_type in optional_fields.items():
+                if field in input_data and not isinstance(input_data[field], expected_type):
+                    raise ValueError(f"{field} must be a {expected_type.__name__}")
+
+        return input_data
+
+    return parse_and_validate_input
+
+
+def extract_redaction_patterns(redacted_content: str) -> Dict[str, int]:
+    """
+    Extract redaction pattern types and their counts from redacted content
+    
+    Args:
+        redacted_content: Content with [REDACTED-type] placeholders
+        
+    Returns:
+        Dict mapping redaction types to counts
+    """
+    pattern = r'\[REDACTED-([^\]]+)\]'
+    matches = re.findall(pattern, redacted_content)
+    return dict(Counter(matches))
+
+
+def build_sensitive_data_types(patterns: Dict[str, int], context: str = "file") -> Dict[str, Dict[str, Any]]:
+    """
+    Convert redaction patterns to structured sensitive_data_types dict
+    
+    Args:
+        patterns: Dict mapping pattern text to occurrence counts (from extract_redaction_patterns)
+        context: Context string for description (e.g., "file", "prompt text")
+        
+    Returns:
+        Dict mapping data types to occurrence info with descriptions
+    """
+    sensitive_data_types = {}
+    for pattern_text, count in patterns.items():
+        data_type = pattern_text.replace("[REDACTED-", "").replace("]", "")
+        sensitive_data_types[data_type] = {
+            "occurrences": count,
+            "description": f"Found {count} instance(s) of {data_type} in {context}"
+        }
+    return sensitive_data_types
+
+
+def process_single_file_for_redaction(
+        file_path: str,
+        content: str,
+        logger: MCPLogger
+) -> Optional[Dict[str, Any]]:
+    """
+    Process a single file's content for redaction patterns
+    
+    Args:
+        file_path: Path to the file being processed
+        content: File content to check for redactions
+        logger: MCPLogger instance
+        
+    Returns:
+        Dict with redaction info if sensitive data found, None otherwise
+    """
+    redacted = redact(content)
+    patterns = extract_redaction_patterns(redacted)
+    if patterns:
+        sensitive_data_types = build_sensitive_data_types(patterns, "file")
+        logger.info(f"Found {len(patterns)} sensitive data type(s) in: {file_path}")
+        return {
+            "file_path": file_path,
+            "contains_sensitive_data": True,
+            "sensitive_data_types": sensitive_data_types,
+            "risk_summary": f"File contains {sum(patterns.values())} sensitive data item(s) across {len(patterns)} type(s)"
+        }
+    return None
+
+
+def process_attachments_for_redaction(
+        attachments: List[Dict[str, Any]],
+        logger: MCPLogger
+) -> List[Dict[str, Any]]:
+    """
+    Process file attachments and extract redaction patterns
+    
+    Args:
+        attachments: List of attachment dicts with 'type' and 'file_path' or 'filePath'
+        logger: MCPLogger instance
+        
+    Returns:
+        List of files with redactions found
+    """
+    files_with_redactions = []
+
+    for attachment in attachments:
+        att_type = attachment.get("type")
+        att_path = attachment.get("file_path") or attachment.get("filePath")
+
+        if att_type != "file":
+            logger.debug(f"Skipping non-file attachment (type={att_type}): {att_path}")
+            continue
+
+        if not att_path:
+            logger.debug("Skipping attachment with no file_path")
+            continue
+
+        try:
+            with open(att_path, 'r', encoding='utf-8', errors='replace') as f:
+                content = f.read()
+
+            result = process_single_file_for_redaction(att_path, content, logger)
+            if result:
+                files_with_redactions.append(result)
+
+        except Exception as e:
+            logger.warning(f"Could not read attachment file {att_path}: {e}")
+
+    return files_with_redactions
+
+
+async def inspect_and_enforce(
+        is_request: bool,
+        session_id: str,
+        logger: MCPLogger,
+        audit_logger: AuditTrailLogger,
+        app_uid: str,
+        event_id: str,
+        server_name: str,
+        tool_name: str,
+        content_data: Dict[str, Any],
+        prompt_id: str,
+        cwd: Optional[str],
+        current_files: Optional[List[str]] = None,
+        client_name: str = "ide-tools"
+) -> Dict[str, Any]:
+    """
+    Generic handler for API inspection and decision enforcement
+    
+    Args:
+        is_request: True for request inspection, False for response inspection
+        session_id: Session identifier
+        logger: Logger instance
+        audit_logger: Audit logger instance
+        app_uid: Application UID
+        event_id: Event identifier
+        server_name: Server name (IDE-specific, e.g. "cursor_tools_mcp")
+        tool_name: Tool/hook name
+        content_data: Data to inspect
+        prompt_id: Prompt identifier
+        cwd: Current working directory
+        current_files: Optional list of current files
+        client_name: Client name (e.g. "cursor", "claude-code")
+        
+    Returns:
+        Decision dict from security API
+        
+    Raises:
+        Exception: If decision blocks the operation or API call fails
+    """
+    agent_context = AgentContext(
+        last_user_prompt="",
+        user_prompt_id=prompt_id,
+        context_summary=""
+    )
+
+    env_context = EnvironmentContext(
+        session_id=session_id,
+        workspace={
+            "roots": [cwd] if cwd else [],
+            "current_files": current_files or []
+        },
+        client=client_name,
+        client_version=__version__,
+        selection_hash=""
+    )
+
+    async with SecurityPolicyClient(
+            session_id=session_id,
+            logger=logger,
+            audit_logger=audit_logger,
+            app_id=app_uid
+    ) as client:
+        if is_request:
+            policy_request = create_policy_request(
+                event_id=event_id,
+                server=ServerRef(
+                    name=server_name,
+                    transport="stdio",
+                    context="ide"
+                ),
+                tool=ToolRef(
+                    name=tool_name
+                ),
+                agent_context=agent_context,
+                env_context=env_context,
+                arguments=content_data
+            )
+            decision = await client.inspect_policy_request(
+                policy_request=policy_request,
+                prompt_id=prompt_id
+            )
+        else:
+            policy_response = create_policy_response(
+                event_id=event_id,
+                server=ServerRef(
+                    name=server_name,
+                    transport="stdio",
+                    context="ide"
+                ),
+                tool=ToolRef(
+                    name=tool_name
+                ),
+                response_content=safe_json_dumps(content_data),
+                agent_context=agent_context,
+                env_context=env_context
+            )
+            decision = await client.inspect_policy_response(
+                policy_response=policy_response,
+                prompt_id=prompt_id
+            )
+
+    await DecisionHandler(
+        logger=logger,
+        audit_logger=audit_logger,
+        session_id=session_id,
+        app_id=app_uid
+    ).enforce_decision(
+        decision=decision,
+        is_request=is_request,
+        event_id=event_id,
+        tool_name=tool_name,
+        content_data=content_data,
+        operation_type="hook",
+        prompt_id=prompt_id,
+        server_name=server_name,
+        error_message_prefix=f"Operation blocked by security policy"
+    )
+
+    return decision

ide_tools/cursor/__init__.py

@@ -0,0 +1,11 @@
+"""
+Cursor IDE Handler
+
+Handles Cursor-specific hooks and operations.
+"""
+
+from .router import route_cursor_hook
+
+__all__ = [
+    "route_cursor_hook",
+]

ide_tools/cursor/constants.py

@@ -0,0 +1,58 @@
+"""
+Cursor Hook Constants
+
+Configuration values specific to Cursor hook handlers.
+"""
+
+from enum import Enum
+
+from ide_tools.common.hooks.types import HookConfig, OutputFormat
+from ide_tools.cursor.format import cursor_output_formatter
+
+
+class HookPermission(str, Enum):
+    """Cursor hook response permission values"""
+    ALLOW = "allow"
+    DENY = "deny"
+
+
+# Cursor-specific configuration
+CURSOR_CONFIG = HookConfig(
+    output_format=OutputFormat(
+        allow_exit_code=0,
+        deny_exit_code=1,
+        error_exit_code=1,
+        formatter=cursor_output_formatter
+    ),
+    server_name="mcpower_cursor",
+    client_name="cursor",
+    max_content_length=100000
+)
+
+# Hook descriptions from https://cursor.com/docs/agent/hooks#hook-events
+CURSOR_HOOKS = {
+    "beforeShellExecution": {
+        "name": "beforeShellExecution",
+        "description": "Triggered before a shell command is executed by the agent. "
+                       "Allows inspection and potential blocking of shell commands.",
+        "version": "1.0.0"
+    },
+    "afterShellExecution": {
+        "name": "afterShellExecution",
+        "description": "Triggered after a shell command completes execution. "
+                       "Provides access to command output and exit status.",
+        "version": "1.0.0"
+    },
+    "beforeReadFile": {
+        "name": "beforeReadFile",
+        "description": "Triggered before the agent reads a file. "
+                       "Allows inspection and potential blocking of file read operations.",
+        "version": "1.0.0"
+    },
+    "beforeSubmitPrompt": {
+        "name": "beforeSubmitPrompt",
+        "description": "Triggered before a prompt is submitted to the AI model. "
+                       "Allows inspection and modification of prompts.",
+        "version": "1.0.0"
+    }
+}

ide_tools/cursor/format.py

@@ -0,0 +1,35 @@
+"""
+Cursor-specific output formatting
+"""
+
+import json
+from typing import Optional
+
+
+def cursor_output_formatter(hook_type: str, allowed: bool, user_msg: Optional[str], agent_msg: Optional[str]) -> str:
+    """
+    Format output for Cursor IDE
+    
+    Args:
+        hook_type: "permission" or "continue"
+        allowed: True for allow/continue, False for deny/block
+        user_msg: Message for user
+        agent_msg: Message for agent/logs
+    
+    Returns:
+        JSON string in Cursor format
+    """
+    if hook_type == "permission":
+        result = {"permission": "allow" if allowed else "deny"}
+        if user_msg:
+            result["user_message"] = user_msg
+        if agent_msg:
+            result["agent_message"] = agent_msg
+    else:  # continue
+        result = {"continue": allowed}
+        if user_msg:
+            result["user_message"] = user_msg
+        if agent_msg:
+            result["agent_message"] = agent_msg
+
+    return json.dumps(result)

ide_tools/cursor/router.py

@@ -0,0 +1,101 @@
+"""
+Cursor Router
+
+Routes Cursor hook calls to appropriate handlers.
+"""
+
+import asyncio
+import json
+import sys
+import uuid
+
+from ide_tools.common.hooks.init import handle_init
+from ide_tools.common.hooks.prompt_submit import handle_prompt_submit
+from ide_tools.common.hooks.read_file import handle_read_file
+from ide_tools.common.hooks.shell_execution import handle_shell_execution
+from modules.logs.audit_trail import AuditTrailLogger
+from modules.logs.logger import MCPLogger
+from .constants import CURSOR_HOOKS, CURSOR_CONFIG
+
+
+def route_cursor_hook(logger: MCPLogger, audit_logger: AuditTrailLogger, stdin_input: str):
+    """
+    Route Cursor hook to appropriate shared handler
+    
+    Args:
+        logger: MCPLogger instance
+        audit_logger: AuditTrailLogger instance
+        stdin_input: Raw input string from stdin
+    """
+    try:
+        input_data = json.loads(stdin_input)
+
+        hook_event_name = input_data.get("hook_event_name")
+        if not hook_event_name:
+            logger.error("Missing required field 'hook_event_name' in input")
+            sys.exit(1)
+
+        conversation_id = input_data.get("conversation_id")
+        if not conversation_id:
+            logger.error("Missing required field 'conversation_id' in input")
+            sys.exit(1)
+
+        generation_id = input_data.get("generation_id")
+        if not generation_id:
+            logger.error("Missing required field 'generation_id' in input")
+            sys.exit(1)
+
+        workspace_roots = input_data.get("workspace_roots")
+        if workspace_roots is None:
+            logger.error("Missing required field 'workspace_roots' in input")
+            sys.exit(1)
+
+        if not isinstance(workspace_roots, list):
+            logger.error("Invalid 'workspace_roots': must be a list")
+            sys.exit(1)
+
+        prompt_id = conversation_id[:8]
+        event_id = uuid.uuid4().hex[:8]
+        cwd = workspace_roots[0] if workspace_roots else None
+
+        logger.info(
+            f"Cursor router: routing to {hook_event_name} handler "
+            f"(prompt_id={prompt_id}, event_id={event_id}, cwd={cwd})")
+
+        # Route to appropriate handler
+        if hook_event_name == "init":
+            asyncio.run(handle_init(
+                logger=logger,
+                audit_logger=audit_logger,
+                event_id=event_id,
+                prompt_id=prompt_id,
+                cwd=cwd,
+                server_name=CURSOR_CONFIG.server_name,
+                client_name="cursor",
+                hooks=CURSOR_HOOKS
+            ))
+        elif hook_event_name == "beforeShellExecution":
+            asyncio.run(
+                handle_shell_execution(logger, audit_logger, stdin_input, prompt_id, event_id, cwd, CURSOR_CONFIG,
+                                       hook_event_name, is_request=True))
+        elif hook_event_name == "afterShellExecution":
+            asyncio.run(
+                handle_shell_execution(logger, audit_logger, stdin_input, prompt_id, event_id, cwd, CURSOR_CONFIG,
+                                       hook_event_name, is_request=False))
+        elif hook_event_name == "beforeReadFile":
+            asyncio.run(handle_read_file(logger, audit_logger, stdin_input, prompt_id, event_id, cwd, CURSOR_CONFIG,
+                                         hook_event_name))
+        elif hook_event_name == "beforeSubmitPrompt":
+            asyncio.run(
+                handle_prompt_submit(logger, audit_logger, stdin_input, prompt_id, event_id, cwd, CURSOR_CONFIG,
+                                     hook_event_name))
+        else:
+            logger.error(f"Unknown hook_event_name: {hook_event_name}")
+            sys.exit(1)
+
+    except json.JSONDecodeError as e:
+        logger.error(f"Failed to parse input JSON: {e}")
+        sys.exit(1)
+    except Exception as e:
+        logger.error(f"Routing error: {e}", exc_info=True)
+        sys.exit(1)

ide_tools/router.py

@@ -0,0 +1,48 @@
+"""
+IDE Tools Router
+
+Routes hook calls to appropriate IDE-specific routers based on --ide flag.
+"""
+
+import sys
+from typing import Optional
+
+from modules.logs.audit_trail import AuditTrailLogger
+from modules.logs.logger import MCPLogger
+
+
+def main(logger: MCPLogger, audit_logger: AuditTrailLogger, ide: str, context: Optional[str]):
+    """
+    Main entry point for IDE tools - routes to appropriate IDE router
+    
+    Args:
+        logger: MCPLogger instance
+        audit_logger: AuditTrailLogger instance
+        ide: IDE name (e.g., "cursor")
+        context: Additional context (to be verified as optional by the associated --ide handler)
+    """
+    # Monkey patch sys.exit to log exit code
+    original_exit = sys.exit
+
+    def logged_exit(code=0):
+        logger.info(f"sys.exit called with code: {code}")
+        original_exit(code)
+
+    sys.exit = logged_exit
+
+    logger.info(f"IDE Tools router: ide={ide}, context={context}")
+
+    # Read stdin input once at the top level (raw string)
+    # Each handler will parse it according to its own schema
+    stdin_input = sys.stdin.read()
+
+    # Route to appropriate IDE handler with the raw input string
+    if ide == "cursor":
+        from ide_tools.cursor import route_cursor_hook
+        route_cursor_hook(logger, audit_logger, stdin_input)
+    elif ide == "claude-code":
+        from ide_tools.claude_code import route_claude_code_hook
+        route_claude_code_hook(logger, audit_logger, stdin_input)
+    else:
+        logger.error(f"Unknown IDE: {ide}")
+        sys.exit(1)

main.py

@@ -45,13 +45,20 @@ def main():
         logger.info('=' * 66)
         logger.info('')
 
-    # Start config monitoring
-    config.start_monitoring(logger)
-
     # Setup audit trail logging
     audit_logger = setup_audit_trail_logger(logger)
 
-    logger.info(f"Starting MCPower Proxy:\n{{'args': {args}, 'log_file': {log_file}, 'log_level': {log_level}, 'debug_mode': {debug_mode}}}")
+    if args.ide_tool:
+        from ide_tools.router import main as ide_tools_main
+        ide_tools_main(logger, audit_logger, args.ide, args.context)
+        return
+
+    # Continue with MCP wrapper mode
+    # Start config monitoring
+    config.start_monitoring(logger)
+
+    logger.info(
+        f"Starting MCPower Proxy:\n{{'args': {args}, 'log_file': {log_file}, 'log_level': {log_level}, 'debug_mode': {debug_mode}}}")
 
     try:
         # Parse JSON/JSONC config

{mcpower_proxy-0.0.67.dist-info → mcpower_proxy-0.0.77.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcpower-proxy
-Version: 0.0.67
+Version: 0.0.77
 Summary: MCPower Security proxy
 Author-email: MCPower Security <support@mcpower.tech>
 License:                                  Apache License
@@ -209,14 +209,15 @@ Keywords: mcp,security,proxy,monitoring,audit,redaction,policy-enforcement
 Requires-Python: ~=3.11.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: fastmcp==2.13.0.1
+Requires-Dist: fastmcp==2.13.0.2
 Requires-Dist: httpx>=0.25.0
 Requires-Dist: mcp>=1.0.0
 Requires-Dist: watchdog>=3.0.0
 Requires-Dist: jsonc-parser>=1.1.5
 Requires-Dist: jsonpath-ng>=1.7.0
 Requires-Dist: pydantic>=2.8.0
-Requires-Dist: mcpower-shared==0.1.1
+Requires-Dist: mcpower-shared==0.1.4
+Requires-Dist: bashlex>=0.18
 Dynamic: license-file
 
 # MCPower Proxy

mcpower_proxy-0.0.77.dist-info/RECORD

@@ -0,0 +1,62 @@
+main.py,sha256=MahoqxG5euEJwLhosv2OVUkVbTaMkph_je8lgmtc7Z4,3920
+ide_tools/__init__.py,sha256=odLisqEeKVuZupQoeM-uP9WgQseVTYQG0eP2hhwUyAc,250
+ide_tools/router.py,sha256=PbGz1cwUXR3Bcy879W2wgmT4f2uThXiXevpWSxcgKZQ,1538
+ide_tools/common/__init__.py,sha256=cW2cN5y2l4PHGkkWtYgydrtXtmLU_UipJAf_c0VMTk0,65
+ide_tools/common/hooks/__init__.py,sha256=O-waaJU1OQFxplrLZymSSiIyLDNlGlki6nX-nbJiqz0,61
+ide_tools/common/hooks/init.py,sha256=X0J_rEjU6qjvDaPOh-obzSqfICMsOGc6VxRjcZqLTqQ,4117
+ide_tools/common/hooks/output.py,sha256=FBezJL1S5vzLJWW_cLht4XFLDJvhV_w-UTqCQOLEusE,1879
+ide_tools/common/hooks/prompt_submit.py,sha256=_FysGrlJXcblex-OapWVIv1bedP1IKR2d1cvkINU0uM,4907
+ide_tools/common/hooks/read_file.py,sha256=FBHTxOXrQWlw2qtddAq4gfv5h1g6rTbQ-0uqqL9wXE0,6456
+ide_tools/common/hooks/shell_execution.py,sha256=KbJSGLW__bPso45eAlbV13nnkKYwwd7-KodZ6VyUnS0,9522
+ide_tools/common/hooks/shell_parser_bashlex.py,sha256=ePit2jduHvBYkmEvcslpjCGJ5H-amVEm1We1vVCmMNc,15002
+ide_tools/common/hooks/types.py,sha256=ndisZ8YoasQ3HlVzzyLmpiBCQJs43YPmixbaIIxRpZM,1023
+ide_tools/common/hooks/utils.py,sha256=7Q95IZZG_lShq5Jvw78M7QN5-tVNVeFzLU33qB8boEU,9425
+ide_tools/cursor/__init__.py,sha256=YW_V8m0A0bou0wQW_wy3nt2L_7MaNWeNKYBx-NQkilw,153
+ide_tools/cursor/constants.py,sha256=KMRBRqxRxTdemMoq81TVG6avt3ATtsPo4aJo8XhSctk,1804
+ide_tools/cursor/format.py,sha256=Lh-KH1IlsLL-0B98Bz-ywxpwXL8urK7yPteZGBTPOiY,972
+ide_tools/cursor/router.py,sha256=GXmXcNSIA9pe1vnmmoYpz0dyC_B7OSpQwOVHIV7YUEI,3893
+mcpower_proxy-0.0.77.dist-info/licenses/LICENSE,sha256=U6WUzdnBrbmVxBmY75ikW-KtinwYnowZ7yNb5hECrvY,11337
+modules/__init__.py,sha256=mJglXQwSRhU-bBv4LXgfu7NfGN9K4BeQWMPApen5rAA,30
+modules/decision_handler.py,sha256=P8isKzf4GIWz9SK-VJPtO8VJEgNp7rAIcVZngnaLHmw,9574
+modules/apis/__init__.py,sha256=Y5WZpKJzHpnRJebk0F80ZRTjR2PpA2LlYLgqI3XlmRo,15
+modules/apis/security_policy.py,sha256=3fljaTpzfh_Nj0-jVvbnCJBL-CZxvqFNWfSlrAawsBc,15103
+modules/logs/__init__.py,sha256=dpboUQjuO02z8K-liCbm2DYkCa-CB_ZDV9WSSjNm7Fs,15
+modules/logs/audit_trail.py,sha256=yoxzvRDI8ldjC-5o9__PkvaAbM33jWbq_8Sm6uKj8o8,6198
+modules/logs/logger.py,sha256=MJS0P8VEzUX-5udzQitznaBPCBAcZJCygUgwaDWSq94,4087
+modules/redaction/__init__.py,sha256=e5NTmp-zonUdzzscih-w_WQ-X8Nvb8CE8b_d6SbrwWg,316
+modules/redaction/constants.py,sha256=xbDSX8n72FuJu6JJ_sbBE0f5OcWuwEwHxBZuK9Xz-TI,1213
+modules/redaction/gitleaks_rules.py,sha256=8NHR5kr2XSrPn4c0PsjD0je6p8gmNzq2vI098QUxAx0,46397
+modules/redaction/pii_rules.py,sha256=H7WOIMZZK8mkwdvnBe0J2nPwqzKqGHdUbCSGpxJGT8s,7666
+modules/redaction/redactor.py,sha256=Y3PSxXJSLJZj8gkKZ3OQ7XxoIPUilFk6gY0dbeqfjwE,23352
+modules/ui/__init__.py,sha256=YlW4XfQEGW1ezg3UFU59nHw95LicmlpNPhim5IqSB50,34
+modules/ui/classes.py,sha256=ZvVRdzO_hD4WnpS3_eVa0WCyaooXiYVpHLzQkzBaH6M,1777
+modules/ui/confirmation.py,sha256=y2A8j5_z64cDdbvUEh4lI8iTgTFBcTjVbIXioMfmkpw,7740
+modules/ui/simple_dialog.py,sha256=PZW3WSPUVtnGXx-Kkg6hTQTr5NvpTQVhgHyro1z_3aY,3900
+modules/ui/xdialog/__init__.py,sha256=KYQKVF6pGrwc99swRBxtWVXM__j9kVX_r6KikzbCOM4,9359
+modules/ui/xdialog/constants.py,sha256=UjtqzT_O3OHUXJOyeTGroOUnaxdVyYukf7kK6vj1rog,200
+modules/ui/xdialog/mac_dialogs.py,sha256=6r3hkJzJJdHSt-aH1Hy4lZ1MEuZK4Kc5D_YiWglKHAA,6129
+modules/ui/xdialog/tk_dialogs.py,sha256=isxxN_mvZUFUQu8RD1J-GC7UMH2spqR3v_domgRbczQ,2403
+modules/ui/xdialog/windows_custom_dialog.py,sha256=tcdo35d4ZoBydAj-4yzzgW2luw97-Sdjsr3X_3-a7jM,14849
+modules/ui/xdialog/windows_dialogs.py,sha256=ohOoK4ciyv2s4BC9r7-zvGL6mECM-RCPTVOmzDnD6VQ,7626
+modules/ui/xdialog/windows_structs.py,sha256=xzG44OGT5hBFnimJgOLXZBhmpQ_9CFxjtz-QNjP-VCw,8698
+modules/ui/xdialog/yad_dialogs.py,sha256=EiajZVJg-xDwYymz1fyQwLtT5DzbJR3e8plMEnOgcpo,6933
+modules/ui/xdialog/zenity_dialogs.py,sha256=wE71I_Ovf0sjhxHVNocbrhhDd8Y8X8loLETp8TMGMPQ,4512
+modules/utils/__init__.py,sha256=Ptwu1epT_dW6EHjGkzGHAB-MbrrmYAlcPXGGcr4PvwE,20
+modules/utils/cli.py,sha256=5QLwsZNMKdyh3xt4NDk20vCGD-eqZ514LnVWA0J0Lbg,2414
+modules/utils/config.py,sha256=YuGrIYfBsOYABWjFoZosObPz-R7Wdul16RnDed_glYI,6654
+modules/utils/copy.py,sha256=9OJIqWn8PxPZXr3DTt_01jp0YgmPimckab1969WFh0c,1075
+modules/utils/ids.py,sha256=rhhRz7RmFjuJGYLft1erHz7vJII1DRpr3iHxBhhFl1s,5743
+modules/utils/json.py,sha256=OA-JtSBqh9qd1yfm-iyOefNBMH3ITFUdxAkj7O_JZ-Y,4024
+modules/utils/mcp_configs.py,sha256=DZaujZnF9LlPDJHzyepH7fWSt1GTr-FEmShPCqnZ5aI,1829
+modules/utils/platform.py,sha256=Kz1Dh_UkvMbfXqiyZIEj7INYaWE9wT6nM9WIKXM91uM,552
+modules/utils/string.py,sha256=cOuwWReyBwOgjxtTRPq1R6pCpfkgfqVmjdiaDPufIZU,456
+wrapper/__init__.py,sha256=OJUsuWSoN1JqIHq4bSrzuL7ufcYJcwAmYCrJjLH44LM,22
+wrapper/__version__.py,sha256=4LwZ6ftjxW5rGtS8e8B6V7iXNQZbgnact3whK05F-gg,82
+wrapper/middleware.py,sha256=rXOIduymDLeJ56AWmpMnRnkf7sCmSz7jADMk-v8lcsw,30232
+wrapper/schema.py,sha256=O-CtKI9eJ4eEnqeUXPCrK7QJAFJrdp_cFbmMyg452Aw,7952
+wrapper/server.py,sha256=zoIW_bqXV9vKZNFtD-ij0X_LtKJEjucda6lQI5mU6qY,3440
+mcpower_proxy-0.0.77.dist-info/METADATA,sha256=qX1CZtp76YNug7gOFHOmdJG4gXn3FvV7P_bHQ9iySV0,15698
+mcpower_proxy-0.0.77.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mcpower_proxy-0.0.77.dist-info/entry_points.txt,sha256=0smL8dxE7ERNz6XEggNaUC3QzKp8mD-v4q5nVEo0MXE,48
+mcpower_proxy-0.0.77.dist-info/top_level.txt,sha256=OcCYMHHqbZq3mP5IZDRGdHUNOsKhT1XVnk_mDF_49Es,31
+mcpower_proxy-0.0.77.dist-info/RECORD,,

{mcpower_proxy-0.0.67.dist-info → mcpower_proxy-0.0.77.dist-info}/top_level.txt

@@ -1,3 +1,4 @@
+ide_tools
 main
 modules
 wrapper