Update app.py

app.py

@@ -1,14 +1,9 @@
 import os
 import json
 import logging
-import numpy as np
 import asyncio
 import aiohttp
-import subprocess
-import sys
-import time
-import threading
-from fastapi import FastAPI, HTTPException, BackgroundTasks, WebSocket, WebSocketDisconnect
+from fastapi import FastAPI, HTTPException, BackgroundTasks
 from fastapi.responses import HTMLResponse
 from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel, Field
@@ -21,26 +16,18 @@ from transformers import (
     StoppingCriteria,
     StoppingCriteriaList,
 )
-import pyautogui
-import psutil
-import cv2
-from PIL import Image, ImageGrab
-import pynput
-from pynput import keyboard, mouse
-import win32api
-import win32con
-import win32gui
-import win32process
-import ctypes
-from ctypes import wintypes
-import pythoncom
-import pygetwindow as gw
-from selenium import webdriver
-from selenium.webdriver.chrome.options import Options
-from webdriver_manager.chrome import ChromeDriverManager
+import requests
+import re
+import time
+from datetime import datetime
+import hashlib
+import nest_asyncio
 import warnings
 warnings.filterwarnings("ignore")
 
+# تطبيق nest-asyncio للتعامل مع الأحداث غير المتزامنة
+nest_asyncio.apply()
+
 # التهيئة الأساسية
 os.environ["HF_HOME"] = "/tmp/hf_cache"
 os.environ["TRANSFORMERS_CACHE"] = "/tmp/hf_cache/transformers"
@@ -61,26 +48,21 @@ logger = logging.getLogger(__name__)
 # نماذج البيانات
 class WindowsTask(BaseModel):
     task_description: str = Field(..., min_length=5, max_length=2000)
-    task_type: str = "analysis"  # analysis, bot_creation, software_install, hacking, automation
+    task_type: str = "analysis"
     game_name: Optional[str] = None
-    priority: str = "normal"  # low, normal, high, critical
-
-class SystemCommand(BaseModel):
-    command: str
-    args: List[str] = []
-    run_as_admin: bool = False
-    timeout: int = 30
+    priority: str = "normal"
 
-class GameAnalysisRequest(BaseModel):
-    game_name: str
-    analysis_type: str = "memory"  # memory, network, process, file, all
-    depth: str = "deep"  # quick, standard, deep
+class ClientCommand(BaseModel):
+    command_type: str  # execute, analyze, create_bot, install, monitor
+    parameters: Dict[str, Any]
+    client_id: Optional[str] = None
 
-class BotCreationRequest(BaseModel):
-    game_name: str
-    bot_type: str  # farming, combat, trading, mining, etc.
-    features: List[str] = []
-    complexity: str = "advanced"
+class ClientResponse(BaseModel):
+    client_id: str
+    command_id: str
+    status: str
+    results: Dict[str, Any]
+    error: Optional[str] = None
 
 # نموذج التوقف المخصص
 class StopOnTokens(StoppingCriteria):
@@ -91,23 +73,20 @@ class StopOnTokens(StoppingCriteria):
                 return True
         return False
 
-# النظام الأساسي المتقدم للتحكم في Windows
-class WindowsAIController:
+# النظام الأساسي المتقدم للذكاء الاصطناعي
+class WindowsAIAdvisor:
     def __init__(self):
         self.tokenizer = None
         self.model = None
         self.pipeline = None
         self.is_loaded = False
-        self.active_processes = {}
-        self.bot_threads = {}
-        self.system_monitor = None
+        self.connected_clients = {}
         self.load_models()
-        self.initialize_system_hooks()
         
     def load_models(self):
         """تحميل النماذج المتخصصة"""
         try:
-            logger.info("جارٍ تحميل النماذج المتخصصة للتحكم في النظام...")
+            logger.info("جارٍ تحميل النماذج المتخصصة...")
             
             model_name = "microsoft/DialoGPT-medium"
             self.tokenizer = AutoTokenizer.from_pretrained(
@@ -144,44 +123,6 @@ class WindowsAIController:
             logger.error(f"فشل تحميل النماذج: {e}")
             raise e
 
-    def initialize_system_hooks(self):
-        """تهيئة خطاطف النظام"""
-        try:
-            # بدء مراقب النظام
-            self.system_monitor = SystemMonitor()
-            self.system_monitor.start()
-            
-            # تهيئة خطاطف لوحة المفاتيح والفأرة
-            self.keyboard_listener = pynput.keyboard.Listener(
-                on_press=self.on_key_press,
-                on_release=self.on_key_release
-            )
-            self.keyboard_listener.start()
-            
-            logger.info("تم تهيئة خطاطف النظام بنجاح")
-        except Exception as e:
-            logger.error(f"فشل تهيئة خطاطف النظام: {e}")
-
-    def on_key_press(self, key):
-        """معالجة ضغطات المفاتيح"""
-        try:
-            key_str = str(key).replace("'", "")
-            # يمكن تسجيل الضغطات لأغراض البوتات
-            if hasattr(self, 'active_bot') and self.active_bot:
-                self.active_bot.handle_key_press(key_str)
-        except Exception as e:
-            logger.debug(f"خطأ في معالجة ضغط المفتاح: {e}")
-
-    def on_key_release(self, key):
-        """معالجة تحرير المفاتيح"""
-        try:
-            key_str = str(key).replace("'", "")
-            # إيقاف البوت عند الضغط على Escape
-            if key == keyboard.Key.esc:
-                self.stop_all_bots()
-        except Exception as e:
-            logger.debug(f"خطأ في معالجة تحرير المفتاح: {e}")
-
     def generate_ai_response(self, prompt: str, context: List[Dict] = None) -> str:
         """توليد رد الذكاء الاصطناعي"""
         try:
@@ -217,689 +158,235 @@ class WindowsAIController:
             logger.error(f"فشل توليد الرد: {e}")
             return f"عذراً، حدث خطأ في معالجة طلبك: {str(e)}"
 
-    async def execute_windows_task(self, task: WindowsTask) -> Dict:
-        """تنفيذ مهمة Windows متقدمة"""
-        try:
-            task_plan = self.analyze_task(task.task_description)
-            
-            results = {
-                "task_id": f"task_{int(time.time())}",
-                "task_type": task.task_type,
-                "status": "running",
-                "steps": [],
-                "results": {},
-                "errors": []
-            }
-            
-            # تنفيذ المهمة بناءً على النوع
-            if task.task_type == "analysis":
-                await self.perform_game_analysis(task, results)
-            elif task.task_type == "bot_creation":
-                await self.create_game_bot(task, results)
-            elif task.task_type == "software_install":
-                await self.install_required_software(task, results)
-            elif task.task_type == "hacking":
-                await self.perform_hacking_analysis(task, results)
-            elif task.task_type == "automation":
-                await self.create_automation_script(task, results)
-            
-            results["status"] = "completed"
-            return results
-            
-        except Exception as e:
-            logger.error(f"فشل تنفيذ المهمة: {e}")
-            return {"error": str(e), "status": "failed"}
-
     def analyze_task(self, task_description: str) -> Dict:
-        """تحليل المهمة وتخطيط التنفيذ"""
+        """تحليل المهمة وإنشاء خطة تنفيذ"""
         analysis_prompt = f"""
-        قم بتحليل المهمة التالية وتخطيط خطوات التنفيذ:
+        قم بتحليل المهمة التالية وإنشاء خطة تنفيذ مفصلة للعميل على Windows:
         {task_description}
         
-        قدم خطة تنفيذ مفصلة تشمل:
+        قدم خطة تنفيذ تشمل:
         1. الأدوات المطلوبة
         2. الخطوات التقنية
-        3. المخاطر المحتملة
-        4. البدائل
+        3. الأوامر المطلوبة
+        4. المخاطر المحتملة
+        5. البدائل
+        
+        ركز على الجانب العملي والتنفيذي.
         """
         
         plan = self.generate_ai_response(analysis_prompt)
-        return {"plan": plan, "steps": self.extract_steps_from_plan(plan)}
+        
+        return {
+            "plan": plan,
+            "steps": self.extract_execution_steps(plan),
+            "tools": self.extract_required_tools(plan),
+            "commands": self.generate_client_commands(plan, task_description)
+        }
 
-    def extract_steps_from_plan(self, plan: str) -> List[str]:
+    def extract_execution_steps(self, plan: str) -> List[str]:
         """استخراج خطوات التنفيذ من الخطة"""
         steps = []
         lines = plan.split('\n')
         
         for line in lines:
             line = line.strip()
-            if any(marker in line for marker in ['1.', '2.', '3.', '4.', '5.', '- ', '• ']):
+            if any(marker in line for marker in ['1.', '2.', '3.', '4.', '5.', '- ', '• ', 'خطوة']):
                 if len(line) > 10:
-                    steps.append(line)
+                    # تنظيف الخطوة
+                    clean_step = re.sub(r'^[0-9•\-\.,]+\s*', '', line)
+                    steps.append(clean_step)
         
-        return steps[:10]  # إرجاع أول 10 خطوات فقط
-
-    async def perform_game_analysis(self, task: WindowsTask, results: Dict):
-        """تحليل لعبة متقدم"""
-        try:
-            game_name = task.game_name or self.extract_game_name(task.task_description)
-            
-            results["steps"].append("بدء تحليل اللعبة...")
-            
-            # 1. البحث عن معلومات اللعبة
-            game_info = await self.research_game(game_name)
-            results["results"]["game_info"] = game_info
-            
-            # 2. تحليل عملية اللعبة
-            process_analysis = self.analyze_game_process(game_name)
-            results["results"]["process_analysis"] = process_analysis
-            
-            # 3. فحص ملفات اللعبة
-            file_analysis = self.analyze_game_files(game_name)
-            results["results"]["file_analysis"] = file_analysis
-            
-            # 4. تحليل الذاكرة
-            memory_analysis = await self.analyze_game_memory(game_name)
-            results["results"]["memory_analysis"] = memory_analysis
-            
-            # 5. تحليل الشبكة
-            network_analysis = await self.analyze_network_traffic(game_name)
-            results["results"]["network_analysis"] = network_analysis
-            
-            results["steps"].append("اكتمل تحليل اللعبة بنجاح")
-            
-        except Exception as e:
-            results["errors"].append(f"خطأ في تحليل اللعبة: {str(e)}")
-            logger.error(f"فشل تحليل اللعبة: {e}")
-
-    async def create_game_bot(self, task: WindowsTask, results: Dict):
-        """إنشاء بوت للعبة"""
-        try:
-            game_name = task.game_name or self.extract_game_name(task.task_description)
-            
-            results["steps"].append("بدء بناء البوت...")
-            
-            # 1. تحليل متطلبات البوت
-            bot_requirements = self.analyze_bot_requirements(task.task_description)
-            results["results"]["requirements"] = bot_requirements
-            
-            # 2. إنشاء كود البوت
-            bot_code = self.generate_bot_code(game_name, bot_requirements)
-            results["results"]["bot_code"] = bot_code
-            
-            # 3. تجميع البوت
-            bot_file = self.compile_bot(bot_code, game_name)
-            results["results"]["bot_file"] = bot_file
-            
-            # 4. اختبار البوت
-            test_results = await self.test_bot(bot_file, game_name)
-            results["results"]["test_results"] = test_results
-            
-            results["steps"].append("اكتمل بناء البوت بنجاح")
-            
-        except Exception as e:
-            results["errors"].append(f"خطأ في بناء البوت: {str(e)}")
-            logger.error(f"فشل بناء البوت: {e}")
-
-    async def install_required_software(self, task: WindowsTask, results: Dict):
-        """تثبيت البرامج المطلوبة"""
-        try:
-            software_list = self.extract_software_requirements(task.task_description)
-            
-            results["steps"].append("بدء تثبيت البرامج...")
-            
-            installed_software = []
-            for software in software_list:
-                try:
-                    installation_result = await self.install_software(software)
-                    installed_software.append({
-                        "software": software,
-                        "status": "installed",
-                        "details": installation_result
-                    })
-                except Exception as e:
-                    installed_software.append({
-                        "software": software,
-                        "status": "failed",
-                        "error": str(e)
-                    })
-            
-            results["results"]["installed_software"] = installed_software
-            results["steps"].append("اكتمل تثبيت البرامج")
-            
-        except Exception as e:
-            results["errors"].append(f"خطأ في تثبيت البرامج: {str(e)}")
-            logger.error(f"فشل تثبيت البرامج: {e}")
-
-    def extract_game_name(self, description: str) -> str:
-        """استخراج اسم اللعبة من الوصف"""
-        # تحليل الوصف للعثور على اسم اللعبة
-        words = description.lower().split()
-        game_keywords = ['game', 'لعبة', 'game:', 'لعبة:']
+        return steps[:15]  # إرجاع أول 15 خطوة فقط
+
+    def extract_required_tools(self, plan: str) -> List[str]:
+        """استخراج الأدوات المطلوبة"""
+        tools = []
+        common_tools = [
+            'cheat engine', 'wireshark', 'process hacker', 'process explorer',
+            'x64dbg', 'ollydbg', 'ida', 'ghidra', 'dnspy', 'reflector',
+            'python', 'visual studio', 'net reflector', 'api monitor'
+        ]
         
-        for i, word in enumerate(words):
-            if word in game_keywords and i + 1 < len(words):
-                return words[i + 1].title()
+        plan_lower = plan.lower()
+        for tool in common_tools:
+            if tool in plan_lower:
+                tools.append(tool)
         
-        return "Unknown_Game"
-
-    async def research_game(self, game_name: str) -> Dict:
-        """البحث عن معلومات اللعبة"""
-        try:
-            research_prompt = f"""
-            ابحث عن المعلومات التقنية للعبة {game_name}:
-            - محرك اللعبة
-            - لغة البرمجة
-            - طرق الحماية
-            - نقاط الضعف المعروفة
-            - أدوات التعديل الشائعة
-            """
-            
-            info = self.generate_ai_response(research_prompt)
-            return {"game_name": game_name, "technical_info": info}
-            
-        except Exception as e:
-            return {"error": str(e)}
+        return tools
 
-    def analyze_game_process(self, game_name: str) -> Dict:
-        """تحليل عملية اللعبة"""
-        try:
-            processes = []
-            for proc in psutil.process_iter(['pid', 'name', 'memory_info', 'cpu_percent']):
-                try:
-                    if game_name.lower() in proc.info['name'].lower():
-                        processes.append({
-                            "pid": proc.info['pid'],
-                            "name": proc.info['name'],
-                            "memory_usage": proc.info['memory_info'].rss / 1024 / 1024,  # MB
-                            "cpu_usage": proc.info['cpu_percent'],
-                            "modules": self.get_process_modules(proc.info['pid'])
-                        })
-                except (psutil.NoSuchProcess, psutil.AccessDenied):
-                    continue
-            
-            return {"processes": processes, "total_found": len(processes)}
-            
-        except Exception as e:
-            return {"error": str(e)}
-
-    def get_process_modules(self, pid: int) -> List[str]:
-        """الحصول على وحدات العملية"""
-        try:
-            process = psutil.Process(pid)
-            modules = []
-            for lib in process.memory_maps():
-                modules.append(lib.path)
-            return modules[:20]  # إرجاع أول 20 وحدة فقط
-        except:
-            return []
-
-    def analyze_game_files(self, game_name: str) -> Dict:
-        """تحليل ملفات اللعبة"""
-        try:
-            common_paths = [
-                f"C:\\Program Files\\{game_name}",
-                f"C:\\Program Files (x86)\\{game_name}",
-                f"D:\\Games\\{game_name}",
-                os.path.expanduser(f"~\\Documents\\{game_name}")
-            ]
-            
-            game_files = {}
-            for path in common_paths:
-                if os.path.exists(path):
-                    files = self.scan_game_directory(path)
-                    game_files[path] = files
-            
-            return {"scanned_paths": common_paths, "found_files": game_files}
-            
-        except Exception as e:
-            return {"error": str(e)}
+    def generate_client_commands(self, plan: str, task_description: str) -> List[Dict]:
+        """توليد أوامر للعميل"""
+        commands = []
+        
+        # تحليل نوع المهمة
+        task_lower = task_description.lower()
+        
+        if any(word in task_lower for word in ['تحليل', 'analyze', 'فحص']):
+            commands.extend(self.generate_analysis_commands(task_description))
+        
+        if any(word in task_lower for word in ['بوت', 'bot', 'أتمتة', 'automation']):
+            commands.extend(self.generate_bot_commands(task_description))
+        
+        if any(word in task_lower for word in ['تثبيت', 'install', 'برنامج']):
+            commands.extend(self.generate_installation_commands(task_description))
+        
+        if any(word in task_lower for word in ['اختراق', 'hack', 'exploit']):
+            commands.extend(self.generate_hacking_commands(task_description))
+        
+        return commands
 
-    def scan_game_directory(self, path: str) -> Dict:
-        """مسح مجلد اللعبة"""
-        try:
-            important_files = {
-                "executables": [],
-                "config_files": [],
-                "data_files": [],
-                "log_files": []
+    def generate_analysis_commands(self, task: str) -> List[Dict]:
+        """توليد أوامر التحليل"""
+        return [
+            {
+                "command_type": "analyze",
+                "parameters": {
+                    "task": task,
+                    "analysis_type": "process_memory",
+                    "depth": "deep"
+                },
+                "description": "تحليل عمليات وذاكرة النظام"
+            },
+            {
+                "command_type": "analyze",
+                "parameters": {
+                    "task": task,
+                    "analysis_type": "game_files",
+                    "depth": "standard"
+                },
+                "description": "فحص ملفات اللعبة"
             }
-            
-            for root, dirs, files in os.walk(path):
-                for file in files:
-                    file_path = os.path.join(root, file)
-                    file_ext = os.path.splitext(file)[1].lower()
-                    
-                    if file_ext in ['.exe', '.dll', '.so']:
-                        important_files["executables"].append(file_path)
-                    elif file_ext in ['.ini', '.cfg', '.config', '.xml', '.json']:
-                        important_files["config_files"].append(file_path)
-                    elif file_ext in ['.dat', '.bin', '.pak', '.assets']:
-                        important_files["data_files"].append(file_path)
-                    elif file_ext in ['.log', '.txt']:
-                        important_files["log_files"].append(file_path)
-            
-            return important_files
-            
-        except Exception as e:
-            return {"error": str(e)}
-
-    async def analyze_game_memory(self, game_name: str) -> Dict:
-        """تحليل ذاكرة اللعبة"""
-        try:
-            # هذا يتطلب صلاحيات متقدمة
-            analysis = {
-                "memory_regions": [],
-                "pointers_found": 0,
-                "patterns_detected": []
+        ]
+
+    def generate_bot_commands(self, task: str) -> List[Dict]:
+        """توليد أوامر بناء البوتات"""
+        return [
+            {
+                "command_type": "create_bot",
+                "parameters": {
+                    "task": task,
+                    "bot_type": self.detect_bot_type(task),
+                    "features": self.extract_bot_features(task)
+                },
+                "description": "بناء بوت متخصص"
             }
-            
-            for proc in psutil.process_iter():
-                try:
-                    if game_name.lower() in proc.name().lower():
-                        # تحليل ذاكرة العملية
-                        memory_info = self.advanced_memory_analysis(proc.pid)
-                        analysis["memory_regions"].append({
-                            "process": proc.name(),
-                            "pid": proc.pid,
-                            "analysis": memory_info
-                        })
-                except (psutil.NoSuchProcess, psutil.AccessDenied):
-                    continue
-            
-            return analysis
-            
-        except Exception as e:
-            return {"error": str(e)}
+        ]
 
-    def advanced_memory_analysis(self, pid: int) -> Dict:
-        """تحليل ذاكرة متقدم"""
-        # تنفيذ تحليل الذاكرة باستخدام أدوات متقدمة
-        return {
-            "status": "requires_admin_privileges",
-            "suggested_tools": ["Cheat Engine", "x64dbg", "Process Hacker"]
-        }
-
-    async def analyze_network_traffic(self, game_name: str) -> Dict:
-        """تحليل حركة مرور الشبكة"""
-        try:
-            # استخدام أدوات تحليل الشبكة
-            analysis = {
-                "connections": [],
-                "packet_analysis": {},
-                "servers_detected": []
-            }
-            
-            for proc in psutil.process_iter():
-                try:
-                    if game_name.lower() in proc.name().lower():
-                        connections = proc.connections()
-                        for conn in connections:
-                            if conn.status == 'ESTABLISHED':
-                                analysis["connections"].append({
-                                    "local_address": f"{conn.laddr.ip}:{conn.laddr.port}",
-                                    "remote_address": f"{conn.raddr.ip}:{conn.raddr.port}" if conn.raddr else "N/A",
-                                    "status": conn.status
-                                })
-                except (psutil.NoSuchProcess, psutil.AccessDenied):
-                    continue
-            
-            return analysis
-            
-        except Exception as e:
-            return {"error": str(e)}
-
-    def analyze_bot_requirements(self, description: str) -> Dict:
-        """تحليل متطلبات البوت"""
-        analysis_prompt = f"""
-        قم بتحليل متطلبات البوت من الوصف التالي:
-        {description}
+    def generate_installation_commands(self, task: str) -> List[Dict]:
+        """توليد أوامر التثبيت"""
+        tools = self.extract_tools_from_task(task)
+        commands = []
         
-        حدد:
-        - نوع البوت المطلوب
-        - الميزات الأساسية
-        - التقنيات المناسبة
-        - المخاطر المحتملة
-        """
+        for tool in tools:
+            commands.append({
+                "command_type": "install",
+                "parameters": {
+                    "tool_name": tool,
+                    "silent_mode": True
+                },
+                "description": f"تثبيت {tool}"
+            })
         
-        requirements = self.generate_ai_response(analysis_prompt)
-        return {
-            "analysis": requirements,
-            "bot_type": self.extract_bot_type(description),
-            "features": self.extract_requested_features(description)
-        }
+        return commands
 
-    def extract_bot_type(self, description: str) -> str:
-        """استخراج نوع البوت"""
-        description_lower = description.lower()
+    def generate_hacking_commands(self, task: str) -> List[Dict]:
+        """توليد أوامر الاختراق"""
+        return [
+            {
+                "command_type": "analyze",
+                "parameters": {
+                    "task": task,
+                    "analysis_type": "vulnerability_scan",
+                    "depth": "deep"
+                },
+                "description": "مسح الثغرات الأمنية"
+            },
+            {
+                "command_type": "execute",
+                "parameters": {
+                    "script_type": "exploit",
+                    "task": task
+                },
+                "description": "تنفيذ استغلال الثغرات"
+            }
+        ]
+
+    def detect_bot_type(self, task: str) -> str:
+        """الكشف عن نوع البوت المطلوب"""
+        task_lower = task.lower()
         
-        if any(word in description_lower for word in ['مزرعة', 'farming', 'farm']):
+        if any(word in task_lower for word in ['مزرعة', 'farming', 'farm']):
             return "farming"
-        elif any(word in description_lower for word in ['قتال', 'combat', 'battle']):
+        elif any(word in task_lower for word in ['قتال', 'combat', 'battle']):
             return "combat"
-        elif any(word in description_lower for word in ['تداول', 'trading', 'trade']):
-            return "trading"
-        elif any(word in description_lower for word in ['تعدين', 'mining', 'mine']):
+        elif any(word in task_lower for word in ['تعدين', 'mining', 'mine']):
             return "mining"
+        elif any(word in task_lower for word in ['تداول', 'trading', 'trade']):
+            return "trading"
         else:
             return "general"
 
-    def extract_requested_features(self, description: str) -> List[str]:
-        """استخراج الميزات المطلوبة"""
+    def extract_bot_features(self, task: str) -> List[str]:
+        """استخراج ميزات البوت المطلوبة"""
         features = []
-        description_lower = description.lower()
+        task_lower = task.lower()
         
-        feature_keywords = {
-            'تلقائي': 'auto',
-            'ذكي': 'smart',
-            'سريع': 'fast',
-            'آمن': 'safe',
-            'مخفي': 'hidden',
-            'متقدم': 'advanced'
+        feature_mapping = {
+            'تلقائي': 'auto_detect',
+            'ذكي': 'smart_detection',
+            'سريع': 'fast_execution',
+            'آمن': 'safe_mode',
+            'مخفي': 'stealth_mode',
+            'متقدم': 'advanced_features'
         }
         
-        for arabic, english in feature_keywords.items():
-            if arabic in description_lower or english in description_lower:
+        for arabic, english in feature_mapping.items():
+            if arabic in task_lower or english in task_lower:
                 features.append(english)
         
         return features
 
-    def generate_bot_code(self, game_name: str, requirements: Dict) -> Dict:
-        """توليد كود البوت"""
-        try:
-            code_prompt = f"""
-            قم بإنشاء كود بوت متقدم للعبة {game_name} مع المتطلبات التالية:
-            {requirements}
-            
-            المتطلبات:
-            - كود Python متقدم
-            - استخدام مكتبات مثل pyautogui, cv2, pynput
-            - تضمين التعليقات التوضيحية
-            - معالجة الأخطاء
-            - إمكانية التخصيص
-            """
-            
-            bot_code = self.generate_ai_response(code_prompt)
-            
-            return {
-                "language": "python",
-                "code": bot_code,
-                "requirements": self.extract_code_requirements(bot_code),
-                "installation_commands": self.generate_installation_commands(bot_code)
-            }
-            
-        except Exception as e:
-            return {"error": str(e)}
-
-    def extract_code_requirements(self, code: str) -> List[str]:
-        """استخراج متطلبات الكود"""
-        requirements = []
-        
-        if 'pyautogui' in code:
-            requirements.append('pyautogui')
-        if 'cv2' in code or 'opencv' in code:
-            requirements.append('opencv-python')
-        if 'pynput' in code:
-            requirements.append('pynput')
-        if 'psutil' in code:
-            requirements.append('psutil')
-        
-        return list(set(requirements))
-
-    def generate_installation_commands(self, code: str) -> List[str]:
-        """توليد أوامر التثبيت"""
-        requirements = self.extract_code_requirements(code)
-        commands = []
-        
-        for req in requirements:
-            commands.append(f"pip install {req}")
+    def extract_tools_from_task(self, task: str) -> List[str]:
+        """استخراج الأدوات المطلوبة من المهمة"""
+        tools = []
+        task_lower = task.lower()
         
-        return commands
-
-    def compile_bot(self, bot_code: Dict, game_name: str) -> Dict:
-        """تجميع البوت"""
-        try:
-            # حفظ الكود في ملف
-            timestamp = int(time.time())
-            filename = f"bot_{game_name}_{timestamp}.py"
-            
-            with open(filename, 'w', encoding='utf-8') as f:
-                f.write(bot_code["code"])
-            
-            return {
-                "filename": filename,
-                "full_path": os.path.abspath(filename),
-                "size": os.path.getsize(filename),
-                "status": "compiled"
-            }
-            
-        except Exception as e:
-            return {"error": str(e)}
-
-    async def test_bot(self, bot_file: Dict, game_name: str) -> Dict:
-        """اختبار البوت"""
-        try:
-            test_results = {
-                "syntax_check": "passed",
-                "dependencies_check": "passed",
-                "performance_test": "not_run",
-                "security_scan": "basic"
-            }
-            
-            # فحص بناء الجملة
-            try:
-                with open(bot_file["filename"], 'r') as f:
-                    compile(f.read(), bot_file["filename"], 'exec')
-            except SyntaxError as e:
-                test_results["syntax_check"] = f"failed: {str(e)}"
-            
-            return test_results
-            
-        except Exception as e:
-            return {"error": str(e)}
-
-    def extract_software_requirements(self, description: str) -> List[str]:
-        """استخراج متطلبات البرامج"""
-        software_keywords = {
-            'cheat engine': 'cheat-engine',
+        tool_mapping = {
+            'cheat engine': 'cheat_engine',
             'wireshark': 'wireshark',
-            'process hacker': 'processhacker',
-            'python': 'python',
-            'visual studio': 'visualstudio',
-            'dnspy': 'dnspy',
+            'process hacker': 'process_hacker',
             'x64dbg': 'x64dbg',
             'ollydbg': 'ollydbg',
-            'ida': 'ida-free',
-            'ghidra': 'ghidra'
+            'ida': 'ida',
+            'ghidra': 'ghidra',
+            'python': 'python'
         }
         
-        found_software = []
-        description_lower = description.lower()
-        
-        for keyword, package in software_keywords.items():
-            if keyword in description_lower:
-                found_software.append(package)
-        
-        return found_software
-
-    async def install_software(self, software_name: str) -> Dict:
-        """تثبيت برنامج"""
-        try:
-            # استخدام Chocolatey أو winget للتثبيت
-            install_commands = {
-                'cheat-engine': 'choco install cheat-engine -y',
-                'wireshark': 'choco install wireshark -y',
-                'processhacker': 'choco install processhacker -y',
-                'python': 'choco install python -y',
-                'visualstudio': 'choco install visualstudio2019community -y',
-                'dnspy': 'choco install dnspy -y',
-                'x64dbg': 'choco install x64dbg -y',
-                'ollydbg': 'choco install ollydbg -y',
-                'ida-free': 'choco install ida-free -y',
-                'ghidra': 'choco install ghidra -y'
-            }
-            
-            if software_name in install_commands:
-                command = install_commands[software_name]
-                result = subprocess.run(command, shell=True, capture_output=True, text=True, timeout=300)
-                
-                return {
-                    "command": command,
-                    "return_code": result.returncode,
-                    "output": result.stdout,
-                    "error": result.stderr
-                }
-            else:
-                return {"error": f"لا يوجد أمر تثبيت معروف للبرنامج: {software_name}"}
-                
-        except Exception as e:
-            return {"error": str(e)}
-
-    async def perform_hacking_analysis(self, task: WindowsTask, results: Dict):
-        """تنفيذ تحليل الاختراق"""
-        try:
-            game_name = task.game_name or self.extract_game_name(task.task_description)
-            
-            results["steps"].append("بدء تحليل الاختراق...")
-            
-            # 1. تحليل الثغرات
-            vulnerability_scan = await self.scan_vulnerabilities(game_name)
-            results["results"]["vulnerabilities"] = vulnerability_scan
-            
-            # 2. اختبار الاختراق
-            penetration_test = await self.perform_penetration_test(game_name)
-            results["results"]["penetration_test"] = penetration_test
-            
-            # 3. بناء أدوات الاستغلال
-            exploit_tools = self.build_exploit_tools(game_name, vulnerability_scan)
-            results["results"]["exploit_tools"] = exploit_tools
-            
-            results["steps"].append("اكتمل تحليل الاختراق")
-            
-        except Exception as e:
-            results["errors"].append(f"خطأ في تحليل الاختراق: {str(e)}")
-            logger.error(f"فشل تحليل الاختراق: {e}")
-
-    async def create_automation_script(self, task: WindowsTask, results: Dict):
-        """إنشاء سكريبت أتمتة"""
-        try:
-            results["steps"].append("بدء إنشاء سكريبت الأتمتة...")
-            
-            # تحليل المهمة وإنشاء السكريبت
-            script_code = self.generate_automation_script(task.task_description)
-            results["results"]["script_code"] = script_code
-            
-            # حفظ وتنفيذ السكريبت
-            script_file = self.save_automation_script(script_code)
-            results["results"]["script_file"] = script_file
-            
-            results["steps"].append("اكتمل إنشاء سكريبت الأتمتة")
-            
-        except Exception as e:
-            results["errors"].append(f"خطأ في إنشاء سكريبت الأتمتة: {str(e)}")
-            logger.error(f"فشل إنشاء سكريبت الأتمتة: {e}")
-
-    def generate_automation_script(self, task_description: str) -> Dict:
-        """توليد سكريبت الأتمتة"""
-        prompt = f"""
-        قم بإنشاء سكريبت Python لأتمتة المهمة التالية:
-        {task_description}
-        
-        المتطلبات:
-        - استخدام مكتبات Windows مثل pyautogui, psutil, win32api
-        - معالجة الأخطاء
-        - سجلات التنفيذ
-        - إمكانية التخصيص
-        """
-        
-        script_code = self.generate_ai_response(prompt)
+        for tool_name, tool_id in tool_mapping.items():
+            if tool_name in task_lower:
+                tools.append(tool_id)
         
-        return {
-            "language": "python",
-            "code": script_code,
-            "libraries": self.extract_code_requirements(script_code)
+        return tools
+
+    def register_client(self, client_id: str, client_info: Dict):
+        """تسجيل عميل جديد"""
+        self.connected_clients[client_id] = {
+            **client_info,
+            "last_seen": datetime.now(),
+            "status": "connected"
         }
+        logger.info(f"تم تسجيل العميل: {client_id}")
 
-    def save_automation_script(self, script_data: Dict) -> Dict:
-        """حفظ سكريبت الأتمتة"""
-        try:
-            timestamp = int(time.time())
-            filename = f"automation_script_{timestamp}.py"
-            
-            with open(filename, 'w', encoding='utf-8') as f:
-                f.write(script_data["code"])
-            
-            return {
-                "filename": filename,
-                "full_path": os.path.abspath(filename),
-                "status": "saved"
-            }
-        except Exception as e:
-            return {"error": str(e)}
-
-    def stop_all_bots(self):
-        """إيقاف جميع البوتات النشطة"""
-        try:
-            for thread_name, thread in self.bot_threads.items():
-                if thread.is_alive():
-                    thread.stop()
-                    logger.info(f"تم إيقاف البوت: {thread_name}")
-            
-            self.bot_threads = {}
-        except Exception as e:
-            logger.error(f"خطأ في إيقاف البوتات: {e}")
-
-    def get_system_info(self) -> Dict:
-        """الحصول على معلومات النظام"""
-        try:
-            return {
-                "os": f"Windows {sys.getwindowsversion().major}",
-                "architecture": platform.architecture()[0],
-                "processor": platform.processor(),
-                "memory": f"{psutil.virtual_memory().total / 1024 / 1024 / 1024:.2f} GB",
-                "python_version": platform.python_version(),
-                "running_processes": len(psutil.pids()),
-                "active_bots": len(self.bot_threads)
-            }
-        except Exception as e:
-            return {"error": str(e)}
-
-# فئة مراقب النظام
-class SystemMonitor(threading.Thread):
-    def __init__(self):
-        super().__init__()
-        self.daemon = True
-        self.running = True
-        self.metrics = {
-            "cpu_usage": [],
-            "memory_usage": [],
-            "active_processes": [],
-            "network_activity": []
-        }
-    
-    def run(self):
-        while self.running:
-            try:
-                # جمع مقاييس النظام
-                self.metrics["cpu_usage"].append(psutil.cpu_percent(interval=1))
-                self.metrics["memory_usage"].append(psutil.virtual_memory().percent)
-                self.metrics["active_processes"].append(len(psutil.pids()))
-                
-                # الحفاظ على تاريخ محدود
-                for key in self.metrics:
-                    if len(self.metrics[key]) > 60:  # آخر 60 قراءة
-                        self.metrics[key] = self.metrics[key][-60:]
-                
-                time.sleep(5)
-            except Exception as e:
-                logger.error(f"خطأ في مراقب النظام: {e}")
-                time.sleep(10)
-    
-    def stop(self):
-        self.running = False
+    def update_client_status(self, client_id: str, status: str):
+        """تحديث حالة العميل"""
+        if client_id in self.connected_clients:
+            self.connected_clients[client_id].update({
+                "last_seen": datetime.now(),
+                "status": status
+            })
 
 # تهيئة النظام
-windows_ai = WindowsAIController()
+ai_advisor = WindowsAIAdvisor()
 
 # نقاط النهاية
 @app.get("/", response_class=HTMLResponse)
@@ -908,157 +395,176 @@ async def read_root():
     with open("static/index.html", "r", encoding="utf-8") as f:
         return HTMLResponse(content=f.read())
 
-@app.post("/api/execute-task")
-async def execute_windows_task(task: WindowsTask):
-    """تنفيذ مهمة Windows"""
-    try:
-        results = await windows_ai.execute_windows_task(task)
-        return {"success": True, "data": results}
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.post("/api/analyze-game")
-async def analyze_game(request: GameAnalysisRequest):
-    """تحليل لعبة محددة"""
+@app.post("/api/analyze-task")
+async def analyze_windows_task(task: WindowsTask):
+    """تحليل المهمة وإنشاء خطة تنفيذ"""
     try:
-        task = WindowsTask(
-            task_description=f"تحليل لعبة {request.game_name} بنوع {request.analysis_type}",
-            task_type="analysis",
-            game_name=request.game_name
-        )
+        analysis = ai_advisor.analyze_task(task.task_description)
         
-        results = await windows_ai.perform_game_analysis(task, {})
-        return {"success": True, "data": results}
+        return {
+            "success": True,
+            "data": {
+                "task_id": f"task_{int(time.time())}",
+                "analysis": analysis,
+                "generated_commands": analysis["commands"],
+                "execution_plan": analysis["plan"]
+            }
+        }
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
-@app.post("/api/create-bot")
-async def create_bot(request: BotCreationRequest):
-    """إنشاء بوت للعبة"""
+@app.post("/api/generate-bot")
+async def generate_bot_script(task: WindowsTask):
+    """توليد سكريبت بوت متخصص"""
     try:
-        task = WindowsTask(
-            task_description=f"إنشاء بوت {request.bot_type} للعبة {request.game_name}",
-            task_type="bot_creation",
-            game_name=request.game_name
-        )
+        bot_prompt = f"""
+        قم بإنشاء سكريبت بوت متقدم للعبة للغرض التالي:
+        {task.task_description}
         
-        results = await windows_ai.create_game_bot(task, {})
-        return {"success": True, "data": results}
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.post("/api/run-command")
-async def run_system_command(command: SystemCommand):
-    """تنفيذ أمر نظام"""
-    try:
-        if command.run_as_admin:
-            # تنفيذ كمسؤول (يتطلب UAC)
-            full_command = f"runas /user:Administrator {' '.join([command.command] + command.args)}"
-        else:
-            full_command = f"{command.command} {' '.join(command.args)}"
+        المتطلبات:
+        - استخدام لغة C++ أو C# لتجنب الاكتشاف
+        - تقنيات التخفي والتشويش
+        - معالجة الأخطاء
+        - إمكانية التخصيص
+        - تجنب أنظمة الحماية
         
-        result = subprocess.run(
-            full_command,
-            shell=True,
-            capture_output=True,
-            text=True,
-            timeout=command.timeout
-        )
+        قدم الكود كاملاً مع الشرح.
+        """
+        
+        bot_code = ai_advisor.generate_ai_response(bot_prompt)
         
         return {
             "success": True,
             "data": {
-                "command": full_command,
-                "return_code": result.returncode,
-                "stdout": result.stdout,
-                "stderr": result.stderr
+                "bot_script": bot_code,
+                "language": "cpp",
+                "features": ai_advisor.extract_bot_features(task.task_description),
+                "compilation_instructions": self.generate_compilation_instructions(bot_code)
             }
         }
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
-@app.get("/api/system-info")
-async def get_system_info():
-    """الحصول على معلومات النظام"""
-    try:
-        info = windows_ai.get_system_info()
-        return {"success": True, "data": info}
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.get("/api/active-processes")
-async def get_active_processes():
-    """الحصول على العمليات النشطة"""
+@app.post("/api/generate-exploit")
+async def generate_exploit_code(task: WindowsTask):
+    """توليد كود استغلال متخصص"""
     try:
-        processes = []
-        for proc in psutil.process_iter(['pid', 'name', 'memory_percent', 'cpu_percent']):
-            try:
-                processes.append(proc.info)
-            except (psutil.NoSuchProcess, psutil.AccessDenied):
-                continue
+        exploit_prompt = f"""
+        قم بإنشاء كود استغلال متقدم للغرض التالي:
+        {task.task_description}
         
-        return {"success": True, "data": processes[:50]}  # إرجاع أول 50 عملية فقط
+        المتطلبات:
+        - استخدام تقنيات متقدمة
+        - تجنب الاكتشاف
+        - معالجة الذاكرة
+        - استغلال الثغرات
+        - كود آمن وقابل للتنفيذ
+        """
+        
+        exploit_code = ai_advisor.generate_ai_response(exploit_prompt)
+        
+        return {
+            "success": True,
+            "data": {
+                "exploit_code": exploit_code,
+                "techniques_used": self.extract_exploit_techniques(exploit_code),
+                "risk_level": "high",
+                "instructions": "يتطلب خبرة متقدمة في التنفيذ"
+            }
+        }
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
-@app.websocket("/ws/system-monitor")
-async def websocket_system_monitor(websocket: WebSocket):
-    """مراقبة النظام عبر WebSocket"""
-    await websocket.accept()
+@app.post("/api/client/register")
+async def register_client(client_info: Dict):
+    """تسجيل عميل جديد"""
     try:
-        while True:
-            # إرسال بيانات المراقبة
-            system_data = {
-                "cpu_usage": psutil.cpu_percent(),
-                "memory_usage": psutil.virtual_memory().percent,
-                "active_processes": len(psutil.pids()),
-                "timestamp": time.time()
+        client_id = client_info.get("client_id", f"client_{int(time.time())}")
+        ai_advisor.register_client(client_id, client_info)
+        
+        return {
+            "success": True,
+            "data": {
+                "client_id": client_id,
+                "status": "registered",
+                "server_time": datetime.now().isoformat()
             }
-            
-            await websocket.send_json(system_data)
-            await asyncio.sleep(2)  # تحديث كل ثانيتين
-            
-    except WebSocketDisconnect:
-        logger.info("تم فصل اتصال WebSocket")
-    except Exception as e:
-        logger.error(f"خطأ في WebSocket: {e}")
-
-@app.post("/api/stop-all-bots")
-async def stop_all_bots():
-    """إيقاف جميع البوتات النشطة"""
-    try:
-        windows_ai.stop_all_bots()
-        return {"success": True, "message": "تم إيقاف جميع البوتات"}
+        }
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
-@app.get("/api/installed-software")
-async def get_installed_software():
-    """الحصول على البرامج المثبتة"""
+@app.post("/api/client/command")
+async def send_client_command(command: ClientCommand):
+    """إرسال أمر للعميل"""
     try:
-        # استخدام wmic للحصول على قائمة البرامج
-        result = subprocess.run(
-            'wmic product get name,version',
-            shell=True,
-            capture_output=True,
-            text=True
-        )
-        
-        software_list = []
-        lines = result.stdout.split('\n')[1:]  # تخطي العنوان
-        for line in lines:
-            if line.strip():
-                parts = line.split('  ')
-                if len(parts) >= 2:
-                    software_list.append({
-                        "name": parts[0].strip(),
-                        "version": parts[1].strip() if len(parts) > 1 else "Unknown"
-                    })
+        # هنا يمكن حفظ الأمر في قاعدة بيانات pending commands
+        command_id = f"cmd_{int(time.time())}"
         
-        return {"success": True, "data": software_list[:100]}  # إرجاع أول 100 برنامج
+        return {
+            "success": True,
+            "data": {
+                "command_id": command_id,
+                "command": command,
+                "status": "sent_to_client",
+                "timestamp": datetime.now().isoformat()
+            }
+        }
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
+@app.get("/api/system/status")
+async def get_system_status():
+    """الحصول على حالة النظام"""
+    return {
+        "success": True,
+        "data": {
+            "ai_model_loaded": ai_advisor.is_loaded,
+            "connected_clients": len(ai_advisor.connected_clients),
+            "server_uptime": "running",
+            "timestamp": datetime.now().isoformat()
+        }
+    }
+
+def generate_compilation_instructions(self, code: str) -> str:
+    """توليد تعليمات التجميع"""
+    if "cpp" in code.lower() or "c++" in code.lower():
+        return """
+        تعليمات التجميع لـ C++:
+        1. احفظ الكود بامتداد .cpp
+        2. استخدم Microsoft Visual Studio
+        3. عطل تحذيرات الأمان مؤقتاً
+        4. جمّع كـ Release x64
+        5. شغّل الملف الناتج كمسؤول
+        """
+    elif "c#" in code.lower() or "csharp" in code.lower():
+        return """
+        تعليمات التجميع لـ C#:
+        1. احفظ الكود بامتداد .cs
+        2. استخدم Visual Studio أو .NET SDK
+        3. جمّع باستخدام: csc /out:bot.exe script.cs
+        4. شغّل الملف الناتج
+        """
+    else:
+        return "تعليمات التجميع: استخدم المترجم المناسب للغة المستخدمة"
+
+def extract_exploit_techniques(self, code: str) -> List[str]:
+    """استخراج تقنيات الاستغلال المستخدمة"""
+    techniques = []
+    code_lower = code.lower()
+    
+    if "buffer" in code_lower and "overflow" in code_lower:
+        techniques.append("Buffer Overflow")
+    if "injection" in code_lower:
+        techniques.append("Code Injection")
+    if "dll" in code_lower:
+        techniques.append("DLL Injection")
+    if "hook" in code_lower:
+        techniques.append("API Hooking")
+    if "memory" in code_lower and "write" in code_lower:
+        techniques.append("Memory Writing")
+    
+    return techniques
+
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)