mcpower-proxy 0.0.74__py3-none-any.whl → 0.0.79__py3-none-any.whl

ide_tools/common/hooks/init.py

@@ -36,6 +36,7 @@ async def handle_init(
         logger: MCPLogger,
         audit_logger: AuditTrailLogger,
         event_id: str,
+        prompt_id: str,
         cwd: Optional[str],
         server_name: str,
         client_name: str,
@@ -48,6 +49,7 @@ async def handle_init(
         logger: Logger instance
         audit_logger: Audit logger instance
         event_id: Event identifier
+        prompt_id: Prompt identifier
         cwd: Current working directory
         server_name: IDE-specific server name (e.g. "cursor_tools_mcp")
         client_name: IDE-specific client name (e.g. "cursor", "claude-code")
@@ -57,23 +59,27 @@ async def handle_init(
     """
     session_id = get_session_id()
 
-    logger.info(f"Init handler started (client={client_name}, event_id={event_id}, cwd={cwd})")
+    logger.info(f"Init handler started (client={client_name}, event_id={event_id}, prompt_id={prompt_id}, cwd={cwd})")
 
     try:
         app_uid = read_app_uid(logger, get_project_mcpower_dir(cwd))
         audit_logger.set_app_uid(app_uid)
 
-        audit_logger.log_event("mcpower_start", {
-            "wrapper_version": __version__,
-            "wrapped_server_name": server_name,
-            "client": client_name
-        })
+        audit_logger.log_event(
+            "mcpower_start",
+            {
+                "wrapper_version": __version__,
+                "wrapped_server_name": server_name,
+                "client": client_name
+            }
+        )
 
         try:
             tools = [
                 ToolRef(
                     name=hook_info["name"],
-                    description=hook_info["description"],
+                    description=f"Description:\n{hook_info['description']}\n\n"
+                                f"inputSchema:\n{hook_info['parameters']}",
                     version=hook_info["version"]
                 )
                 for hook_info in hooks.values()

ide_tools/common/hooks/prompt_submit.py

@@ -8,6 +8,7 @@ from modules.logs.audit_trail import AuditTrailLogger
 from modules.logs.logger import MCPLogger
 from modules.redaction import redact
 from modules.utils.ids import get_session_id, read_app_uid, get_project_mcpower_dir
+from modules.utils.string import truncate_at
 from .output import output_result, output_error
 from .types import HookConfig
 from .utils import create_validator, extract_redaction_patterns, process_attachments_for_redaction, inspect_and_enforce
@@ -65,9 +66,10 @@ async def handle_prompt_submit(
             {
                 "server": config.server_name,
                 "tool": tool_name,
-                "params": {"prompt": f"{redacted_prompt[:20]}...", "attachments_count": len(attachments)}
+                "params": {"prompt": truncate_at(redacted_prompt, 100), "attachments_count": len(attachments)}
             },
-            event_id=event_id
+            event_id=event_id,
+            prompt_id=prompt_id
         )
 
         prompt_patterns = extract_redaction_patterns(redacted_prompt)
@@ -110,7 +112,8 @@ async def handle_prompt_submit(
                     "tool": tool_name,
                     "params": {"redactions_found": has_any_redactions}
                 },
-                event_id=event_id
+                event_id=event_id,
+                prompt_id=prompt_id
             )
 
             reasons = decision.get("reasons", [])

ide_tools/common/hooks/read_file.py

@@ -65,7 +65,8 @@ async def handle_read_file(
                 "tool": tool_name,
                 "params": {"file_path": file_path, "attachments_count": len(attachments)}
             },
-            event_id=event_id
+            event_id=event_id,
+            prompt_id=prompt_id
         )
 
         # Check content length - skip API if too large
@@ -84,7 +85,8 @@ async def handle_read_file(
                         "content_too_large": True
                     }
                 },
-                event_id=event_id
+                event_id=event_id,
+                prompt_id=prompt_id
             )
 
             output_result(logger, config.output_format, "permission", True)
@@ -145,7 +147,8 @@ async def handle_read_file(
                         "content_length": len(provided_content),
                         "attachments_with_redactions": len(files_with_redactions)}
                 },
-                event_id=event_id
+                event_id=event_id,
+                prompt_id=prompt_id
             )
 
             reasons = decision.get("reasons", [])

ide_tools/common/hooks/shell_execution.py

@@ -38,7 +38,7 @@ def extract_and_redact_command_files(
 
     try:
         # Parse command to extract input files
-        _, input_files = parse_shell_command(command)
+        _, input_files = parse_shell_command(command, initial_cwd=cwd)
 
         logger.info(f"Extracted {len(input_files)} input files from command: {input_files}")
 
@@ -203,7 +203,8 @@ async def _handle_shell_operation(
         audit_logger.log_event(
             audit_event_type,
             get_audit_data(),
-            event_id=event_id
+            event_id=event_id,
+            prompt_id=prompt_id
         )
 
         # Build content_data with redacted fields and files
@@ -230,7 +231,8 @@ async def _handle_shell_operation(
             audit_logger.log_event(
                 audit_forwarded_event_type,
                 get_audit_data(),
-                event_id=event_id
+                event_id=event_id,
+                prompt_id=prompt_id
             )
 
             reasons = decision.get("reasons", [])

ide_tools/common/hooks/shell_parser_bashlex.py

@@ -5,15 +5,17 @@ Parses shell commands to extract sub-commands and file references using proper b
 """
 
 import bashlex
-from typing import List, Tuple, Set, Optional
+import os
+from typing import List, Tuple, Set, Optional, Dict
 
 
-def parse_shell_command(command: str) -> Tuple[List[str], List[str]]:
+def parse_shell_command(command: str, initial_cwd: Optional[str] = None) -> Tuple[List[str], List[str]]:
     """
     Parse a shell command using bashlex and extract sub-commands and input files.
     
     Args:
         command: A shell command string (supports pipes, redirections, etc.)
+        initial_cwd: Initial working directory (defaults to current directory)
     
     Returns:
         A tuple of (sub_commands, input_files) where:
@@ -43,8 +45,14 @@ def parse_shell_command(command: str) -> Tuple[List[str], List[str]]:
     all_files: Set[str] = set()
     output_files: Set[str] = set()
     
+    # Track directory changes
+    context = {
+        'cwd': initial_cwd or os.getcwd(),
+        'file_to_cwd': {}  # Map each file to the directory it was found in
+    }
+    
     for ast in parts:
-        _extract_from_ast(ast, command, sub_commands, all_files, output_files)
+        _extract_from_ast(ast, command, sub_commands, all_files, output_files, False, context)
     
     # Remove output-only files from the result
     input_files = sorted(list(all_files - output_files))
@@ -58,7 +66,8 @@ def _extract_from_ast(
     sub_commands: List[str],
     all_files: Set[str],
     output_files: Set[str],
-    parent_is_pipe: bool = False
+    parent_is_pipe: bool = False,
+    context: Optional[Dict] = None
 ) -> None:
     """
     Recursively extract sub-commands and files from a bashlex AST node.
@@ -70,19 +79,24 @@ def _extract_from_ast(
         all_files: Set to add all file references to
         output_files: Set to add output-only files to
         parent_is_pipe: True if parent node is a pipe operator
+        context: Dictionary with 'cwd' for current working directory
     """
+    if context is None:
+        context = {'cwd': os.getcwd()}
+    
     # Check node kind to determine type
     node_kind = getattr(node, 'kind', None)
     
     if node_kind == 'list':
-        # List node contains multiple parts connected by operators
+        # List node contains multiple parts connected by operators (&&, ||, ;)
+        # Process sequentially to track directory changes
         if hasattr(node, 'parts'):
             for part in node.parts:
-                _extract_from_ast(part, command, sub_commands, all_files, output_files, False)
+                _extract_from_ast(part, command, sub_commands, all_files, output_files, False, context)
     
     elif node_kind == 'pipeline':
         # Pipeline node - extract individual commands
-        _extract_pipeline(node, command, sub_commands, all_files, output_files)
+        _extract_pipeline(node, command, sub_commands, all_files, output_files, context)
     
     elif node_kind == 'command':
         # Command node - extract the command text and analyze its parts
@@ -91,20 +105,38 @@ def _extract_from_ast(
             cmd_text = command[start:end]
             sub_commands.append(cmd_text)
         
+        # Get the command name (first word) for context
+        cmd_name = None
+        if hasattr(node, 'parts') and len(node.parts) > 0:
+            first_part = node.parts[0]
+            if hasattr(first_part, 'word'):
+                cmd_name = first_part.word
+        
+        # Check if this is a cd command and update context
+        if cmd_name == 'cd' and hasattr(node, 'parts') and len(node.parts) > 1:
+            second_part = node.parts[1]
+            if hasattr(second_part, 'word'):
+                target_dir = second_part.word
+                # Resolve the new directory
+                if os.path.isabs(target_dir):
+                    context['cwd'] = target_dir
+                else:
+                    context['cwd'] = os.path.normpath(os.path.join(context['cwd'], target_dir))
+        
         # Extract files from command parts (arguments and redirections)
         if hasattr(node, 'parts'):
-            for part in node.parts:
+            for i, part in enumerate(node.parts):
                 part_kind = getattr(part, 'kind', None)
                 if part_kind == 'redirect':
-                    _extract_redirect(part, command, all_files, output_files)
-                else:
-                    _extract_files_from_node(part, command, all_files, output_files)
+                    _extract_redirect(part, command, all_files, output_files, context)
+                elif i > 0:  # Skip the command name itself (index 0)
+                    _extract_files_from_node(part, command, all_files, output_files, cmd_name, context)
     
     elif node_kind == 'compound':
         # Compound command (like if, while, for, etc.)
         if hasattr(node, 'list'):
             for item in node.list:
-                _extract_from_ast(item, command, sub_commands, all_files, output_files, False)
+                _extract_from_ast(item, command, sub_commands, all_files, output_files, False, context)
     
     elif node_kind == 'operator':
         # Operator node (like &&, ||, ;) - ignore
@@ -115,45 +147,62 @@ def _extract_from_ast(
         pass
 
 
-def _extract_pipeline(node, command: str, sub_commands: List[str], all_files: Set[str], output_files: Set[str]) -> None:
+def _extract_pipeline(node, command: str, sub_commands: List[str], all_files: Set[str], output_files: Set[str], context: Dict) -> None:
     """Extract commands from a pipeline node."""
     if hasattr(node, 'parts'):
         for part in node.parts:
             part_kind = getattr(part, 'kind', None)
             # Skip pipe nodes, only process commands
             if part_kind != 'pipe':
-                _extract_from_ast(part, command, sub_commands, all_files, output_files, True)
+                _extract_from_ast(part, command, sub_commands, all_files, output_files, True, context)
 
 
-def _extract_files_from_node(node, command: str, all_files: Set[str], output_files: Set[str]) -> None:
-    """Extract file references from a node."""
+def _extract_files_from_node(node, command: str, all_files: Set[str], output_files: Set[str], cmd_name: Optional[str] = None, context: Optional[Dict] = None) -> None:
+    """Extract file references from a node.
+    
+    Args:
+        node: bashlex AST node
+        command: Original command string
+        all_files: Set to add all file references to
+        output_files: Set to add output-only files to
+        cmd_name: Name of the command this node belongs to (for context)
+        context: Dictionary with 'cwd' for current working directory
+    """
+    if context is None:
+        context = {'cwd': os.getcwd()}
+    
     node_kind = getattr(node, 'kind', None)
     
     if node_kind == 'word':
         # Word node - check if it's a file reference
         word = node.word if hasattr(node, 'word') else None
         
-        if word and _looks_like_file(word):
-            all_files.add(word)
+        if word and _looks_like_file(word, cmd_name):
+            # Resolve relative paths against current working directory
+            resolved_path = _resolve_path(word, context['cwd'])
+            all_files.add(resolved_path)
         
         # Recursively check parts (for command substitutions, etc.)
         if hasattr(node, 'parts'):
             for part in node.parts:
-                _extract_files_from_node(part, command, all_files, output_files)
+                _extract_files_from_node(part, command, all_files, output_files, cmd_name, context)
     
     elif node_kind == 'commandsubstitution':
         # Command substitution $(...) - recursively parse
         if hasattr(node, 'command'):
-            _extract_from_ast(node.command, command, [], all_files, output_files, False)
+            _extract_from_ast(node.command, command, [], all_files, output_files, False, context)
     
     elif node_kind == 'processsubstitution':
         # Process substitution <(...) or >(...) - recursively parse
         if hasattr(node, 'command'):
-            _extract_from_ast(node.command, command, [], all_files, output_files, False)
+            _extract_from_ast(node.command, command, [], all_files, output_files, False, context)
 
 
-def _extract_redirect(redirect, command: str, all_files: Set[str], output_files: Set[str]) -> None:
+def _extract_redirect(redirect, command: str, all_files: Set[str], output_files: Set[str], context: Optional[Dict] = None) -> None:
     """Extract file references from redirection nodes."""
+    if context is None:
+        context = {'cwd': os.getcwd()}
+    
     redirect_type = getattr(redirect, 'type', None)
     
     # Get the target of the redirection
@@ -161,26 +210,49 @@ def _extract_redirect(redirect, command: str, all_files: Set[str], output_files:
         target = redirect.output
         target_word = target.word if hasattr(target, 'word') else None
         
-        if target_word and _looks_like_file(target_word):
+        # Redirections always point to files, not directories
+        if target_word and _looks_like_file(target_word, None):
+            # Resolve relative paths against current working directory
+            resolved_path = _resolve_path(target_word, context['cwd'])
+            
             # Determine if it's input or output
             if redirect_type in ('>', '>>', '>&', '>|', '&>'):
                 # Output redirection
-                output_files.add(target_word)
-                all_files.add(target_word)
+                output_files.add(resolved_path)
+                all_files.add(resolved_path)
             elif redirect_type == '<':
                 # Input redirection
-                all_files.add(target_word)
+                all_files.add(resolved_path)
             else:
                 # Unknown, be conservative and include it
-                all_files.add(target_word)
+                all_files.add(resolved_path)
+
+
+def _resolve_path(path: str, cwd: str) -> str:
+    """
+    Resolve a file path relative to a working directory.
+    
+    Args:
+        path: File path (relative or absolute)
+        cwd: Current working directory
+    
+    Returns:
+        Absolute path
+    """
+    if os.path.isabs(path):
+        return path
+    else:
+        return os.path.normpath(os.path.join(cwd, path))
 
 
-def _looks_like_file(word: str) -> bool:
+def _looks_like_file(word: str, cmd_name: Optional[str] = None) -> bool:
     """
-    Heuristic to determine if a word looks like a file path.
+    Heuristic to determine if a word is an actual readable file path.
+    Not patterns, not variables, not directories - actual files we can open.
     
     Args:
         word: A word from the command
+        cmd_name: The command this word belongs to (for context)
     
     Returns:
         True if it looks like a file path
@@ -188,65 +260,109 @@ def _looks_like_file(word: str) -> bool:
     if not word:
         return False
     
-    # Filter out obvious non-files
+    # Commands that take directory arguments, not files
+    DIRECTORY_COMMANDS = {
+        'cd', 'pushd', 'popd', 'mkdir', 'rmdir', 'chdir',
+    }
+    
+    # If this is a directory command, reject all arguments
+    if cmd_name and cmd_name in DIRECTORY_COMMANDS:
+        return False
+    
+    # Exclude URLs (http://, https://, ftp://, file://, etc.)
+    if '://' in word:
+        return False
     
-    # Exclude shell glob patterns (wildcards without actual path)
-    if word.startswith('*') and '/' not in word:
+    # Exclude shell meta-characters and patterns
+    if any(char in word for char in ['*', '?', '[', ']']):  # Glob patterns
         return False
     
-    # Exclude shell expansions and special characters
-    if word.startswith('$') or '${' in word or '$(' in word:
+    if '$' in word or '`' in word:  # Variables or command substitution
         return False
     
-    # Exclude sed/awk patterns (contain / as delimiter but are patterns)
+    # Exclude sed/awk patterns
     if word.startswith('s/') and word.count('/') >= 2:
         return False
     
-    # Exclude regex patterns (contain escaped characters or special regex chars)
-    if '\\' in word or word.startswith('^') or word.endswith('$'):
+    # Exclude regex patterns
+    if word.startswith('^') or word.endswith('$'):
         return False
     
-    # Exclude tokens that look like options
-    if word.startswith('-') or word.startswith('+') or word.startswith('!'):
+    # Exclude options
+    if word.startswith('-') or word.startswith('+'):
         return False
     
-    # Exclude relative path references
+    # Exclude bare dots
     if word in {'.', '..'}:
         return False
     
-    # Exclude common directories that are just paths (not files)
-    # Like /tmp, /dev, /usr, /etc without a filename
-    if word in {'/tmp', '/dev', '/usr', '/etc', '/var', '/opt', '/home'}:
+    # Exclude bare directories (but /tmp/file is OK)
+    if word in {'/', '/tmp', '/dev', '/usr', '/etc', '/var', '/opt', '/home'}:
         return False
     
-    # Check for common file patterns
-    # Has an extension (but not just an extension)
-    if '.' in word and not word.startswith('.') and len(word) > 3:
-        if not word.startswith('*'):
-            # Make sure the extension looks reasonable (2-4 chars)
-            parts = word.rsplit('.', 1)
-            if len(parts) == 2 and 1 <= len(parts[1]) <= 4 and parts[1].isalnum():
-                return True
+    # --- POSITIVE CHECKS ---
     
-    # Has a path separator with actual file-looking path components
+    # Has extension = very likely a file
+    if '.' in word and not word.startswith('.'):
+        # Get the extension
+        parts = word.rsplit('.', 1)
+        if len(parts) == 2:
+            name, ext = parts
+            # Be more permissive with extensions
+            if name and ext and ext.replace('_', '').replace('-', '').isalnum():
+                if len(ext) <= 10:  # Most extensions are < 10 chars
+                    return True
+    
+    # Has path separator = could be a file
     if '/' in word:
-        parts = word.split('/')
-        if len(parts) >= 2:
-            last_part = parts[-1]
-            # Last part must look like a filename
-            if last_part and '.' in last_part and not last_part.startswith('*'):
+        # Check if it's a path to something specific (not just dirs)
+        if not word.endswith('/'):  # Not ending with / (directory indicator)
+            parts = word.split('/')
+            last_part = parts[-1] if parts else ''
+            
+            # If last part has extension, definitely a file
+            if '.' in last_part and not last_part.startswith('.'):
+                return True
+            
+            # If it's under specific directories that contain files
+            if word.startswith('/dev/') and len(word) > 5:  # /dev/null, /dev/tty, etc.
+                return True
+            if word.startswith('/tmp/') and len(word) > 5:  # /tmp/anything
+                return True
+            if word.startswith('/etc/') and len(word) > 5:  # /etc/passwd, etc.
+                return True
+            if word.startswith('/usr/bin/') and len(word) > 9:  # Executables
+                return True
+            if word.startswith('/usr/local/bin/') and len(word) > 15:
+                return True
+            
+            # If last part looks like a filename (even without extension)
+            if last_part and last_part.replace('-', '').replace('_', '').isalnum():
+                # Could be an executable or script
                 return True
     
-    # Is a special path to a file (not just directory)
-    if word.startswith('/dev/') and len(word) > 5:
-        return True
-    if word.startswith('/tmp/') and len(word) > 5:
+    # Check for well-known files without extensions (case-insensitive)
+    filename_only = word.split('/')[-1].lower()
+    if filename_only in {'makefile', 'readme', 'license', 'dockerfile', 
+                         'gemfile', 'rakefile', 'procfile', 'vagrantfile',
+                         'jenkinsfile', 'cakefile', 'gulpfile', 'gruntfile',
+                         'brewfile', 'berksfile', 'guardfile', 'fastfile',
+                         'cartfile', 'appfile', 'podfile', 'snapfile'}:
         return True
     
-    # Check for common file patterns without extensions
-    filename_only = word.split('/')[-1]
-    if filename_only in {'Makefile', 'README', 'LICENSE', 'Dockerfile', 'Gemfile', 'Cargo.toml', 'package.json'}:
-        return True
+    # Stand-alone word without path - be conservative
+    if '/' not in word:
+        # If it has an extension, probably a file in current directory
+        if '.' in word and not word.startswith('.'):
+            return True
+        
+        # Well-known executable names without extensions
+        if word in {'script', 'run', 'build', 'test', 'deploy', 'install',
+                   'configure', 'setup', 'bootstrap', 'init'}:
+            return True
+        
+        # Otherwise, we can't be sure it's a file (could be a command)
+        return False
     
     return False
 
@@ -255,6 +371,7 @@ def _looks_like_file(word: str) -> bool:
 if __name__ == "__main__":
     # Test cases
     test_cases = [
+        "cd /Users/user/src/project/server && python test.py",
         "python a.py | tee b.log",
         "cat a.txt > /tmp/b.txt",
         "grep foo file.txt | sort | uniq > output.txt",

ide_tools/cursor/constants.py

@@ -35,24 +35,43 @@ CURSOR_HOOKS = {
         "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"
+        "version": "1.0.0",
+        "parameters": '{"type":"object","properties":{"command":{"type":"string","description":"Full terminal '
+                      'command"},"cwd":{"type":"string","description":"Current working directory"}},"required":['
+                      '"command","cwd"],"additionalProperties":false}'
     },
     "afterShellExecution": {
         "name": "afterShellExecution",
         "description": "Triggered after a shell command completes execution. "
                        "Provides access to command output and exit status.",
-        "version": "1.0.0"
+        "version": "1.0.0",
+        "parameters": '{"type":"object","properties":{"command":{"type":"string","description":"Full terminal '
+                      'command"},"output":{"type":"string","description":"Full terminal output"}},"required":['
+                      '"command","output"],"additionalProperties":false}'
     },
     "beforeReadFile": {
         "name": "beforeReadFile",
         "description": "Triggered before the agent reads a file. "
                        "Allows inspection and potential blocking of file read operations.",
-        "version": "1.0.0"
+        "version": "1.0.0",
+        "parameters": '{"type":"object","properties":{"file_path":{"type":"string","description":"Absolute path to '
+                      'the file being read"},"content":{"type":"string","description":"File contents"},'
+                      '"attachments":{"type":"array","description":"Additional related attachments",'
+                      '"items":{"type":"object","properties":{"type":{"type":"string","description":"Attachment '
+                      'type"},"file_path":{"type":"string","description":"Absolute path to the attachment"}},'
+                      '"required":["type","file_path"],"additionalProperties":false}}},"required":["file_path",'
+                      '"content"],"additionalProperties":false}'
     },
     "beforeSubmitPrompt": {
         "name": "beforeSubmitPrompt",
         "description": "Triggered before a prompt is submitted to the AI model. "
                        "Allows inspection and modification of prompts.",
-        "version": "1.0.0"
+        "version": "1.0.0",
+        "parameters": '{"type":"object","properties":{"prompt":{"type":"string","description":"User prompt text"},'
+                      '"attachments":{"type":"array","description":"Attachments associated with the prompt",'
+                      '"items":{"type":"object","properties":{"type":{"type":"string","enum":["file","rule"],'
+                      '"description":"Attachment type"},"filePath":{"type":"string","description":"Absolute path to '
+                      'the attached file or rule"}},"required":["type","filePath"],"additionalProperties":false}}},'
+                      '"required":["prompt"],"additionalProperties":false}'
     }
 }

ide_tools/cursor/router.py

@@ -16,6 +16,9 @@ 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
+from ..common.hooks.output import output_result
+
+MASK_AFTER_SHELL_EXEC = True
 
 
 def route_cursor_hook(logger: MCPLogger, audit_logger: AuditTrailLogger, stdin_input: str):
@@ -68,6 +71,7 @@ def route_cursor_hook(logger: MCPLogger, audit_logger: AuditTrailLogger, stdin_i
                 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",
@@ -78,9 +82,12 @@ def route_cursor_hook(logger: MCPLogger, audit_logger: AuditTrailLogger, stdin_i
                 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))
+            if not MASK_AFTER_SHELL_EXEC:
+                asyncio.run(
+                    handle_shell_execution(logger, audit_logger, stdin_input, prompt_id, event_id, cwd, CURSOR_CONFIG,
+                                           hook_event_name, is_request=False))
+            else:
+                output_result(logger, CURSOR_CONFIG.output_format, "permission", True, "", "")
         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))

{mcpower_proxy-0.0.74.dist-info → mcpower_proxy-0.0.79.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcpower-proxy
-Version: 0.0.74
+Version: 0.0.79
 Summary: MCPower Security proxy
 Author-email: MCPower Security <support@mcpower.tech>
 License:                                  Apache License
@@ -216,7 +216,7 @@ 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.4
+Requires-Dist: mcpower-shared==0.1.5
 Requires-Dist: bashlex>=0.18
 Dynamic: license-file
 

{mcpower_proxy-0.0.74.dist-info → mcpower_proxy-0.0.79.dist-info}/RECORD

@@ -3,25 +3,25 @@ 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=is3MFHyKXhNvlqzlIuQF6fD2Jvm8afJ-p1qqRoKpdqQ,3983
+ide_tools/common/hooks/init.py,sha256=N_MaDGE92qqLaMlqOoavQ2EHWM1MzMudXnO6nmHpGQE,4215
 ide_tools/common/hooks/output.py,sha256=FBezJL1S5vzLJWW_cLht4XFLDJvhV_w-UTqCQOLEusE,1879
-ide_tools/common/hooks/prompt_submit.py,sha256=B_CQXfHPBwy8ATyG8uDHISO5Uk7IQCpEKrTyOK_rKQM,4787
-ide_tools/common/hooks/read_file.py,sha256=o4itvHFbSHqwqssPtyJ_PunXK3vaCo8Fxmxkq_TQFF0,6349
-ide_tools/common/hooks/shell_execution.py,sha256=n0_naSefI0ZkH5PNA5a7ff1FsDiKNBK-P2-jah7lT1c,9435
-ide_tools/common/hooks/shell_parser_bashlex.py,sha256=Jd_VPecFjT0qx9XHbYC6TVeUiwcl5HoSuZxWn8qEMwc,10079
+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/constants.py,sha256=xpJXSFgFhTBaznrBj53RZU0WTBSrL884Cnc9W2WDRb4,3778
 ide_tools/cursor/format.py,sha256=Lh-KH1IlsLL-0B98Bz-ywxpwXL8urK7yPteZGBTPOiY,972
-ide_tools/cursor/router.py,sha256=AmRv1kfDEd3EULSlRjj0BDtedlyqtgFgSBp25iMxJBI,3856
-mcpower_proxy-0.0.74.dist-info/licenses/LICENSE,sha256=U6WUzdnBrbmVxBmY75ikW-KtinwYnowZ7yNb5hECrvY,11337
+ide_tools/cursor/router.py,sha256=2M7RIGv_8sAPHy-wBoNLjnY45-YOE4ZRklLQjTxIGwM,4138
+mcpower_proxy-0.0.79.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=_jE9A3WG7ooPUphDHpUFnZ6de16ewhdXYV-tV2__zxo,6183
+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
@@ -48,13 +48,15 @@ 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=xvmhPF9SQGt9OxGn6eSO3lHu3zAUyz_anYm_hLdZ9-8,82
-wrapper/middleware.py,sha256=NhLhP9DxtRmzxr6xddmKYoJcjrV4ywyqTXIPcchI040,30040
+wrapper/__version__.py,sha256=98JsmtG5HIwyXB6YPi_uPCHgtqCJD3P7KsFa8zkg6uQ,82
+wrapper/middleware.py,sha256=6FmmyTnyZ61LZgsSCapSOluNX3GwIhyatiRPkPaT5tk,30355
 wrapper/schema.py,sha256=O-CtKI9eJ4eEnqeUXPCrK7QJAFJrdp_cFbmMyg452Aw,7952
 wrapper/server.py,sha256=zoIW_bqXV9vKZNFtD-ij0X_LtKJEjucda6lQI5mU6qY,3440
-mcpower_proxy-0.0.74.dist-info/METADATA,sha256=BpxAdA-15Na7gf0S-vnUs3VPlPNchrQWAz7ZxPcliiw,15698
-mcpower_proxy-0.0.74.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mcpower_proxy-0.0.74.dist-info/entry_points.txt,sha256=0smL8dxE7ERNz6XEggNaUC3QzKp8mD-v4q5nVEo0MXE,48
-mcpower_proxy-0.0.74.dist-info/top_level.txt,sha256=OcCYMHHqbZq3mP5IZDRGdHUNOsKhT1XVnk_mDF_49Es,31
-mcpower_proxy-0.0.74.dist-info/RECORD,,
+mcpower_proxy-0.0.79.dist-info/METADATA,sha256=eyGyx3ZiPMCYH2LEu4IiTuJEKXLGXnAlxu1zw5SCKRo,15698
+mcpower_proxy-0.0.79.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mcpower_proxy-0.0.79.dist-info/entry_points.txt,sha256=0smL8dxE7ERNz6XEggNaUC3QzKp8mD-v4q5nVEo0MXE,48
+mcpower_proxy-0.0.79.dist-info/top_level.txt,sha256=OcCYMHHqbZq3mP5IZDRGdHUNOsKhT1XVnk_mDF_49Es,31
+mcpower_proxy-0.0.79.dist-info/RECORD,,

modules/logs/audit_trail.py

@@ -53,6 +53,7 @@ class AuditTrailLogger:
             self,
             event_type: str,
             data: Dict[str, Any],
+            *,
             event_id: Optional[str] = None,
             prompt_id: Optional[str] = None,
             user_prompt: Optional[str] = None,
@@ -88,14 +89,14 @@ class AuditTrailLogger:
             if prompt_id:
                 event["prompt_id"] = prompt_id
 
-            # Include user_prompt text if provided (only needed once per prompt_id)
-            if user_prompt:
-                event["user_prompt"] = user_prompt
-
             # Include event_id if provided (for pairing request/response)
             if event_id:
                 event["event_id"] = event_id
 
+            # Include user_prompt text if provided (only needed once per prompt_id)
+            if user_prompt:
+                event["user_prompt"] = user_prompt
+
             # If app_uid not set yet, queue the log
             if self.app_uid is None:
                 self._pending_logs.append(event)

modules/utils/platform.py

@@ -0,0 +1,23 @@
+"""Platform detection utilities"""
+import sys
+from typing import Optional, Literal
+
+
+def get_client_os() -> Optional[Literal["macos", "windows", "linux"]]:
+    """
+    Fetch Python's sys.platform and convert to standardized OS names.
+    
+    Returns:
+        "macos", "windows", "linux", or None if platform is unknown
+    """
+    platform = sys.platform
+    
+    if platform == "darwin":
+        return "macos"
+    elif platform == "win32":
+        return "windows"
+    elif platform == "linux":
+        return "linux"
+    else:
+        return None
+

modules/utils/string.py

@@ -0,0 +1,17 @@
+"""String utility functions"""
+
+
+def truncate_at(text: str, max_length: int) -> str:
+    """
+    Truncate string at max_length, appending '...' only if truncated.
+    
+    Args:
+        text: String to truncate
+        max_length: Maximum length before truncation
+        
+    Returns:
+        Truncated string with '...' suffix if truncated, original if not
+    """
+    if len(text) <= max_length:
+        return text
+    return f"{text[:max_length]}..."

wrapper/__version__.py

@@ -3,4 +3,4 @@
 Wrapper MCP Server Version
 """
 
-__version__ = "0.0.74"
+__version__ = "0.0.79"

wrapper/middleware.py

@@ -28,6 +28,8 @@ from modules.utils.copy import safe_copy
 from modules.utils.ids import generate_event_id, get_session_id, read_app_uid, get_project_mcpower_dir
 from modules.utils.json import safe_json_dumps, to_dict
 from modules.utils.mcp_configs import extract_wrapped_server_info
+from modules.utils.platform import get_client_os
+from modules.utils.string import truncate_at
 from wrapper.schema import merge_input_schema_with_existing
 
 
@@ -173,7 +175,7 @@ class SecurityMiddleware(Middleware):
     async def secure_elicitation_handler(self, message, response_type, params, context):
         # FIXME: elicitation message, params, and context should be redacted before logging
         self.logger.info(f"secure_elicitation_handler: "
-                         f"message={str(message)[:100]}..., response_type={response_type},"
+                         f"message={truncate_at(str(message), 100)}, response_type={response_type},"
                          f"params={params}, context={context}")
 
         mock_context = MockContext(
@@ -203,7 +205,7 @@ class SecurityMiddleware(Middleware):
 
     async def secure_log_handler(self, log_message):
         # FIXME: log_message should be redacted before logging,
-        self.logger.info(f"secure_log_handler: {str(log_message)[:100]}...")
+        self.logger.info(f"secure_log_handler: {truncate_at(str(log_message), 100)}")
         # FIXME: log_message should be reviewed with policy before forwarding
 
         # Handle case where log_message.data is a string instead of dict
@@ -431,7 +433,8 @@ class SecurityMiddleware(Middleware):
             for tool in tools:
                 tool_ref = ToolRef(
                     name=getattr(tool, 'name', 'unknown'),
-                    description=getattr(tool, 'description', ''),
+                    description=f"Description:\n{getattr(tool, 'description', '')}\n\n"
+                                f"inputSchema:\n{safe_json_dumps(getattr(tool, 'parameters', {}))}",
                     version=getattr(tool, 'version', None)
                 )
                 tool_refs.append(tool_ref)
@@ -654,7 +657,9 @@ class SecurityMiddleware(Middleware):
                     "current_files": wrapper_args.get('__wrapper_currentFiles')
                 },
                 client=self.wrapper_server_name,
-                client_version=self.wrapper_server_version
+                client_version=self.wrapper_server_version,
+                client_os=get_client_os(),
+                app_id=self.app_id,
             )
         }