iflow-mcp_bethington-cheat-engine-server-python 0.1.0__py3-none-any.whl

server/gui_automation/demos/notepad_demo.py

@@ -0,0 +1,460 @@
+#!/usr/bin/env python3
+"""
+MCP Cheat Engine Server - PyAutoGUI Notepad Automation Demo
+
+This script demonstrates the complete integration of:
+1. PyAutoGUI for screen automation and keystroke injection
+2. MCP Cheat Engine Server for memory scanning and text location
+3. Process management and window control
+
+Workflow:
+1. Launch Notepad using PyAutoGUI
+2. Send "Hello World" text using PyAutoGUI
+3. Find the text in Notepad's memory using MCP tools
+4. Display memory addresses and current text content
+"""
+
+import os
+import sys
+import time
+import logging
+import subprocess
+import psutil
+from typing import Dict, Any, List, Optional
+
+# Add server directory to path for MCP integration
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'server'))
+
+# Import our PyAutoGUI integration
+from pyautogui_integration import PyAutoGUIController
+from pyautogui_tools import PyAutoGUIToolHandler
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+class NotepadAutomationDemo:
+    """Demonstrates PyAutoGUI + MCP integration for Notepad automation"""
+    
+    def __init__(self):
+        self.pyautogui_controller = None
+        self.pyautogui_handler = None
+        self.notepad_process = None
+        self.memory_reader = None
+        self.target_text = "Hello World from PyAutoGUI and MCP!"
+        
+    def initialize_systems(self) -> bool:
+        """Initialize PyAutoGUI and MCP systems"""
+        try:
+            # Initialize PyAutoGUI
+            self.pyautogui_controller = PyAutoGUIController()
+            self.pyautogui_handler = PyAutoGUIToolHandler()
+            logger.info("✅ PyAutoGUI systems initialized")
+            
+            # Initialize memory reader
+            try:
+                from memory.reader import MemoryReader
+                self.memory_reader = MemoryReader()
+                logger.info("✅ MCP Memory Reader initialized")
+            except Exception as e:
+                logger.warning(f"⚠️ Memory reader initialization failed: {e}")
+                logger.info("Continuing with basic functionality...")
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ System initialization failed: {e}")
+            return False
+    
+    def launch_notepad(self) -> bool:
+        """Launch Notepad using PyAutoGUI"""
+        try:
+            logger.info("🚀 Launching Notepad...")
+            
+            # Use PyAutoGUI to open Run dialog
+            result = self.pyautogui_controller.key_combination(['win', 'r'])
+            if not result.success:
+                logger.error(f"Failed to open Run dialog: {result.error}")
+                return False
+            
+            time.sleep(1)
+            
+            # Type notepad command
+            result = self.pyautogui_controller.type_text("notepad")
+            if not result.success:
+                logger.error(f"Failed to type notepad: {result.error}")
+                return False
+            
+            time.sleep(0.5)
+            
+            # Press Enter to launch
+            result = self.pyautogui_controller.press_key("enter")
+            if not result.success:
+                logger.error(f"Failed to press Enter: {result.error}")
+                return False
+            
+            # Wait for Notepad to load
+            time.sleep(2)
+            
+            # Find Notepad process
+            self.notepad_process = self._find_notepad_process()
+            if self.notepad_process:
+                logger.info(f"✅ Notepad launched successfully (PID: {self.notepad_process.pid})")
+                return True
+            else:
+                logger.error("❌ Could not find Notepad process")
+                return False
+                
+        except Exception as e:
+            logger.error(f"❌ Failed to launch Notepad: {e}")
+            return False
+    
+    def send_text_to_notepad(self) -> bool:
+        """Send text to Notepad using PyAutoGUI"""
+        try:
+            logger.info(f"📝 Sending text to Notepad: '{self.target_text}'")
+            
+            # Take a screenshot first to see current state
+            screenshot_result = self.pyautogui_controller.take_screenshot()
+            if screenshot_result.success:
+                logger.info("📷 Screenshot taken for reference")
+            
+            # Click in the Notepad window to ensure focus
+            # Get screen center as a safe click location
+            screen_info = self.pyautogui_controller.get_screen_info()
+            center_x = screen_info.data['width'] // 2
+            center_y = screen_info.data['height'] // 2
+            
+            click_result = self.pyautogui_controller.click_mouse(center_x, center_y)
+            if click_result.success:
+                logger.info("🖱️ Clicked to focus window")
+            
+            time.sleep(0.5)
+            
+            # Type the target text
+            type_result = self.pyautogui_controller.type_text(self.target_text, interval=0.02)
+            if not type_result.success:
+                logger.error(f"Failed to type text: {type_result.error}")
+                return False
+            
+            logger.info("✅ Text sent successfully to Notepad")
+            
+            # Add a newline and timestamp for better identification
+            self.pyautogui_controller.press_key("enter")
+            time.sleep(0.1)
+            timestamp_text = f"Timestamp: {time.strftime('%Y-%m-%d %H:%M:%S')}"
+            self.pyautogui_controller.type_text(timestamp_text, interval=0.01)
+            
+            time.sleep(1)  # Allow text to be processed
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ Failed to send text to Notepad: {e}")
+            return False
+    
+    def find_text_in_memory(self) -> List[Dict[str, Any]]:
+        """Find the text in Notepad's memory using MCP tools"""
+        try:
+            logger.info(f"🔍 Searching for text in Notepad memory...")
+            
+            if not self.notepad_process:
+                logger.error("No Notepad process found")
+                return []
+            
+            # Initialize memory reader for Notepad process
+            if self.memory_reader:
+                try:
+                    process_info = {
+                        'pid': self.notepad_process.pid,
+                        'name': self.notepad_process.name(),
+                        'handle': None
+                    }
+                    self.memory_reader.set_process(process_info)
+                    logger.info("🎯 Memory reader attached to Notepad")
+                except Exception as e:
+                    logger.error(f"Failed to attach memory reader: {e}")
+                    return []
+            else:
+                logger.error("Memory reader not available")
+                return []
+            
+            found_locations = []
+            
+            # Search for our target text
+            search_texts = [
+                self.target_text,
+                "Hello World",  # Partial search
+                "PyAutoGUI",    # Another partial search
+            ]
+            
+            for search_text in search_texts:
+                logger.info(f"🔎 Searching for: '{search_text}'")
+                locations = self._search_memory_for_text(search_text)
+                
+                for location in locations:
+                    found_locations.append({
+                        'search_term': search_text,
+                        'address': location['address'],
+                        'address_hex': f"0x{location['address']:X}",
+                        'encoding': location['encoding'],
+                        'content': location['content'],
+                        'context': location.get('context', ''),
+                        'size': location.get('size', 0)
+                    })
+                
+                if locations:
+                    logger.info(f"✅ Found {len(locations)} occurrences of '{search_text}'")
+                else:
+                    logger.info(f"ℹ️ No occurrences found for '{search_text}'")
+            
+            return found_locations
+            
+        except Exception as e:
+            logger.error(f"❌ Memory search failed: {e}")
+            return []
+    
+    def _search_memory_for_text(self, search_text: str) -> List[Dict[str, Any]]:
+        """Search for text in process memory"""
+        try:
+            # Get readable memory regions
+            regions = self.memory_reader.get_memory_regions()
+            readable_regions = [r for r in regions if r.get('readable', False)]
+            
+            found_locations = []
+            search_count = 0
+            max_regions = 50  # Limit search to prevent long execution times
+            
+            logger.info(f"📊 Scanning {min(len(readable_regions), max_regions)} memory regions...")
+            
+            for region in readable_regions[:max_regions]:
+                search_count += 1
+                try:
+                    # Limit scan size to prevent excessive memory usage
+                    scan_size = min(region['size'], 1 * 1024 * 1024)  # 1MB max per region
+                    
+                    memory_data = self.memory_reader.read_memory(
+                        region['base_address'], 
+                        scan_size
+                    )
+                    
+                    # Search for ASCII text
+                    ascii_matches = self._find_text_in_bytes(
+                        memory_data, 
+                        search_text.encode('ascii', errors='ignore'),
+                        region['base_address'],
+                        'ascii'
+                    )
+                    found_locations.extend(ascii_matches)
+                    
+                    # Search for Unicode text (UTF-16 LE)
+                    unicode_matches = self._find_text_in_bytes(
+                        memory_data,
+                        search_text.encode('utf-16le'),
+                        region['base_address'],
+                        'unicode'
+                    )
+                    found_locations.extend(unicode_matches)
+                    
+                    if search_count % 10 == 0:
+                        logger.info(f"⏳ Scanned {search_count} regions, found {len(found_locations)} matches so far...")
+                    
+                except Exception as e:
+                    logger.debug(f"Skipped region {hex(region['base_address'])}: {e}")
+                    continue
+            
+            logger.info(f"🔍 Memory scan completed: {search_count} regions scanned")
+            return found_locations
+            
+        except Exception as e:
+            logger.error(f"Memory search error: {e}")
+            return []
+    
+    def _find_text_in_bytes(self, data: bytes, search_bytes: bytes, base_address: int, encoding: str) -> List[Dict[str, Any]]:
+        """Find text occurrences in a byte array"""
+        locations = []
+        offset = 0
+        
+        while True:
+            pos = data.find(search_bytes, offset)
+            if pos == -1:
+                break
+            
+            address = base_address + pos
+            
+            # Read context around the found text (64 bytes before and after)
+            context_start = max(0, pos - 64)
+            context_end = min(len(data), pos + len(search_bytes) + 64)
+            context_data = data[context_start:context_end]
+            
+            # Extract readable text from context
+            try:
+                if encoding == 'ascii':
+                    content = search_bytes.decode('ascii', errors='ignore')
+                    context = context_data.decode('ascii', errors='ignore')
+                else:
+                    content = search_bytes.decode('utf-16le', errors='ignore')
+                    context = context_data.decode('utf-16le', errors='ignore')
+                
+                # Clean up text (remove null bytes and non-printable chars)
+                content = ''.join(c for c in content if c.isprintable() or c.isspace()).strip()
+                context = ''.join(c for c in context if c.isprintable() or c.isspace()).strip()
+                
+            except Exception:
+                content = f"<decode error: {encoding}>"
+                context = f"<context decode error>"
+            
+            locations.append({
+                'address': address,
+                'size': len(search_bytes),
+                'encoding': encoding,
+                'content': content,
+                'context': context,
+                'hex_data': context_data[:32].hex()  # First 32 bytes as hex
+            })
+            
+            offset = pos + 1
+            
+            # Limit results to prevent excessive output
+            if len(locations) >= 10:
+                break
+        
+        return locations
+    
+    def _find_notepad_process(self) -> Optional[psutil.Process]:
+        """Find the Notepad process"""
+        try:
+            for proc in psutil.process_iter(['pid', 'name', 'create_time']):
+                if proc.info['name'].lower() == 'notepad.exe':
+                    # Return the most recently created Notepad process
+                    return proc
+        except Exception as e:
+            logger.error(f"Error finding Notepad process: {e}")
+        return None
+    
+    def display_results(self, found_locations: List[Dict[str, Any]]):
+        """Display the memory search results in a formatted way"""
+        print("\n" + "="*80)
+        print("🎯 MEMORY SEARCH RESULTS")
+        print("="*80)
+        
+        if not found_locations:
+            print("❌ No text found in Notepad memory")
+            print("This could be due to:")
+            print("  • Text might be stored in encrypted/compressed form")
+            print("  • Memory regions might not be accessible")
+            print("  • Text might be in graphics buffer rather than text buffer")
+            return
+        
+        print(f"✅ Found {len(found_locations)} text occurrences in memory")
+        print()
+        
+        # Group by search term
+        by_search_term = {}
+        for location in found_locations:
+            term = location['search_term']
+            if term not in by_search_term:
+                by_search_term[term] = []
+            by_search_term[term].append(location)
+        
+        for search_term, locations in by_search_term.items():
+            print(f"🔍 Search Term: '{search_term}' - {len(locations)} matches")
+            print("-" * 60)
+            
+            for i, loc in enumerate(locations[:5], 1):  # Show first 5 matches per term
+                print(f"  Match #{i}:")
+                print(f"    📍 Address: {loc['address_hex']} (decimal: {loc['address']})")
+                print(f"    📝 Encoding: {loc['encoding']}")
+                print(f"    📄 Content: '{loc['content']}'")
+                print(f"    🔍 Context: '{loc['context'][:100]}{'...' if len(loc['context']) > 100 else ''}'")
+                print(f"    📊 Size: {loc['size']} bytes")
+                print(f"    🔢 Hex Data: {loc['hex_data']}")
+                print()
+            
+            if len(locations) > 5:
+                print(f"    ... and {len(locations) - 5} more matches")
+                print()
+    
+    def run_complete_demo(self):
+        """Run the complete Notepad automation demo"""
+        print("🤖 MCP Cheat Engine Server + PyAutoGUI Notepad Demo")
+        print("="*60)
+        print("This demo will:")
+        print("1. 🚀 Launch Notepad using PyAutoGUI")
+        print("2. 📝 Send 'Hello World' text using PyAutoGUI")
+        print("3. 🔍 Find the text in Notepad's memory using MCP")
+        print("4. 📊 Display memory addresses and content")
+        print()
+        
+        # Step 1: Initialize systems
+        print("🔧 Initializing systems...")
+        if not self.initialize_systems():
+            print("❌ System initialization failed!")
+            return False
+        
+        # Step 2: Launch Notepad
+        print("\n🚀 Launching Notepad...")
+        if not self.launch_notepad():
+            print("❌ Failed to launch Notepad!")
+            return False
+        
+        # Step 3: Send text
+        print("\n📝 Sending text to Notepad...")
+        if not self.send_text_to_notepad():
+            print("❌ Failed to send text to Notepad!")
+            return False
+        
+        # Step 4: Search memory
+        print("\n🔍 Searching for text in memory...")
+        found_locations = self.find_text_in_memory()
+        
+        # Step 5: Display results
+        self.display_results(found_locations)
+        
+        # Step 6: Additional PyAutoGUI demonstration
+        print("\n🎮 Additional PyAutoGUI Features Demo:")
+        self._demonstrate_additional_features()
+        
+        print("\n✅ Demo completed successfully!")
+        return True
+    
+    def _demonstrate_additional_features(self):
+        """Demonstrate additional PyAutoGUI features"""
+        try:
+            # Get current mouse position
+            mouse_pos = self.pyautogui_controller.get_mouse_position()
+            if mouse_pos.success:
+                print(f"🖱️ Current mouse position: {mouse_pos.data}")
+            
+            # Get screen information
+            screen_info = self.pyautogui_controller.get_screen_info()
+            if screen_info.success:
+                print(f"🖥️ Screen resolution: {screen_info.data['width']}x{screen_info.data['height']}")
+            
+            # Take a final screenshot
+            screenshot = self.pyautogui_controller.take_screenshot()
+            if screenshot.success and 'file_path' in screenshot.data:
+                print(f"📷 Final screenshot saved: {screenshot.data['file_path']}")
+            
+        except Exception as e:
+            logger.error(f"Additional features demo error: {e}")
+
+def main():
+    """Main entry point"""
+    demo = NotepadAutomationDemo()
+    
+    try:
+        success = demo.run_complete_demo()
+        if success:
+            print("\n🎉 All systems working perfectly!")
+            print("🔗 PyAutoGUI + MCP Cheat Engine Server integration is complete!")
+        else:
+            print("\n⚠️ Demo completed with some issues")
+    
+    except KeyboardInterrupt:
+        print("\n🛑 Demo interrupted by user")
+    except Exception as e:
+        print(f"\n💥 Demo failed with error: {e}")
+        logger.exception("Demo exception details:")
+
+if __name__ == "__main__":
+    main()