Upload 58 files

README_background.md

@@ -0,0 +1,168 @@
+
+# نظام العمل في الخلفية
+
+## نظرة عامة
+يوفر هذا النظام إمكانية تشغيل التطبيق كخدمة خلفية دون إظهار واجهات تفاعلية إلا عند الحاجة. مناسب للخوادم والأجهزة التي تعمل على مدار الساعة.
+
+## المكونات الجديدة
+
+### 1. خدمة العمل في الخلفية (`background_service.py`)
+- تدير جميع الخدمات الأساسية في الخلفية
+- توفر HTTP API للتحكم عن بُعد
+- فحص دوري وإعادة تشغيل الخدمات المتوقفة
+- نظام سجلات شامل
+
+### 2. أيقونة شريط النظام (`system_tray.py`)
+- تحكم سريع من شريط النظام
+- إظهار/إخفاء الواجهة التفاعلية حسب الحاجة
+- مراقبة حالة النظام في الوقت الفعلي
+
+### 3. المشغل الموحد (`launcher.py`)
+- واجهة موحدة لجميع أوضاع التشغيل
+- تثبيت تلقائي للاعتماديات
+- خيارات تشغيل متعددة
+
+## طرق التشغيل
+
+### التشغيل مع أيقونة شريط النظام (موصى به)
+```bash
+python launcher.py --tray
+```
+
+### التشغيل التفاعلي (مع واجهة)
+```bash
+python launcher.py --interactive
+```
+
+### التشغيل بدون واجهة (للخوادم)
+```bash
+python launcher.py --headless
+```
+
+### عرض حالة النظام
+```bash
+python launcher.py --status
+```
+
+### إيقاف النظام
+```bash
+python launcher.py --stop
+```
+
+## التحكم عبر HTTP API
+
+الخدمة توفر HTTP API على المنفذ 8888:
+
+### فحص الحالة
+```bash
+curl http://localhost:8888/status
+```
+
+### بدء الخدمات
+```bash
+curl -X POST http://localhost:8888/start
+```
+
+### إيقاف الخدمات
+```bash
+curl -X POST http://localhost:8888/stop
+```
+
+### إظهار الواجهة التفاعلية
+```bash
+curl -X POST http://localhost:8888/show-ui
+```
+
+### إخفاء الواجهة التفاعلية
+```bash
+curl -X POST http://localhost:8888/hide-ui
+```
+
+## الاعتماديات الإضافية
+
+للتشغيل مع أيقونة شريط النظام:
+```bash
+pip install pystray Pillow
+```
+
+أو استخدم:
+```bash
+python launcher.py --install-deps
+```
+
+## التشغيل التلقائي
+
+### Windows
+```bash
+python control.py --enable
+```
+
+### Linux (systemd)
+إنشاء ملف خدمة:
+```bash
+sudo nano /etc/systemd/system/distributed-tasks.service
+```
+
+محتوى الملف:
+```ini
+[Unit]
+Description=Distributed Task System
+After=network.target
+
+[Service]
+Type=simple
+User=your-username
+WorkingDirectory=/path/to/your/project
+ExecStart=/usr/bin/python3 launcher.py --headless
+Restart=always
+RestartSec=10
+
+[Install]
+WantedBy=multi-user.target
+```
+
+تفعيل الخدمة:
+```bash
+sudo systemctl enable distributed-tasks.service
+sudo systemctl start distributed-tasks.service
+```
+
+### macOS
+```bash
+python control.py --enable
+```
+
+## المزايا
+
+1. **العمل في الخلفية**: النظام يعمل دون إزعاج المستخدم
+2. **تحكم مرن**: إظهار الواجهة عند الحاجة فقط
+3. **مراقبة تلقائية**: إعادة تشغيل الخدمات المتوقفة
+4. **تحكم عن بُعد**: HTTP API للتحكم من أي مكان
+5. **سجلات شاملة**: تتبع جميع الأحداث والأخطاء
+6. **دعم منصات متعددة**: Windows, Linux, macOS
+
+## الاستكشاف والإصلاح
+
+### فحص السجلات
+```bash
+tail -f logs/background_service.log
+```
+
+### فحص حالة الخدمات
+```bash
+python launcher.py --status
+```
+
+### إعادة تشغيل النظام
+```bash
+python launcher.py --stop
+python launcher.py --tray
+```
+
+## التخصيص
+
+يمكن تخصيص الخدمة عبر تعديل:
+- منافذ الشبكة في `background_service.py`
+- قائمة الخدمات المُدارة
+- فترات الفحص الدوري
+- مسارات السجلات

ai_assistant.py

@@ -0,0 +1,102 @@
+
+# -*- coding: utf-8 -*-
+
+import os
+import json
+import requests
+from typing import List, Dict
+
+class NoraAssistant:
+    def __init__(self):
+        self.api_key = os.getenv("OPENAI_API_KEY", "your-api-key-here")
+        self.history_path = "history.json"
+        self.chat_history = self.load_history()
+        
+    def load_history(self) -> List[Dict]:
+        """تحميل سجل المحادثة"""
+        if os.path.exists(self.history_path):
+            try:
+                with open(self.history_path, "r", encoding="utf-8") as f:
+                    return json.load(f)
+            except:
+                return []
+        return []
+    
+    def save_history(self):
+        """حفظ سجل المحادثة"""
+        with open(self.history_path, "w", encoding="utf-8") as f:
+            json.dump(self.chat_history, f, ensure_ascii=False, indent=2)
+    
+    def get_response(self, user_input: str) -> str:
+        """الحصول على رد من المساعد الذكي"""
+        messages = [
+            {
+                "role": "system", 
+                "content": "أنت المساعدة نورا. إذا سألك أحد سؤالاً لا تعرفيه، فابحثي في معلوماتك الذاتية. إذا لم تجدي، حاولي التعلم من البحث أو تطوير نفسك."
+            }
+        ]
+        
+        # إضافة آخر 10 رسائل من السجل للسياق
+        messages.extend(self.chat_history[-10:])
+        messages.append({"role": "user", "content": user_input})
+        
+        try:
+            response = requests.post(
+                "https://api.openai.com/v1/chat/completions",
+                headers={
+                    "Authorization": f"Bearer {self.api_key}",
+                    "Content-Type": "application/json"
+                },
+                json={
+                    "model": "gpt-3.5-turbo",
+                    "messages": messages,
+                    "max_tokens": 500,
+                    "temperature": 0.7
+                },
+                timeout=30
+            )
+            
+            if response.status_code == 200:
+                return response.json()["choices"][0]["message"]["content"]
+            else:
+                return f"عذراً، حدث خطأ: {response.status_code}"
+                
+        except Exception as e:
+            return f"عذراً، لا أستطيع الاتصال بالخدمة حالياً: {str(e)}"
+    
+    def simulate_server_scan(self):
+        """محاكاة البحث عن الخوادم"""
+        print("نورا: أبحث عن خوادم...")
+        fake_servers = ["192.168.1.5", "192.168.1.10", "192.168.1.20"]
+        for server in fake_servers:
+            print(f"نورا: تم العثور على خادم مفتوح في {server}")
+            print(f"نورا: أقوم بنسخ نفسي إلى {server} (محاكاة فقط)...")
+    
+    def chat(self):
+        """بدء المحادثة"""
+        print("مرحباً! أنا نورا، مساعدتك الذكية. اكتب 'خروج' للإنهاء أو 'scan' للبحث عن خوادم.")
+        
+        while True:
+            user_input = input("\nأنت: ").strip()
+            
+            if user_input.lower() in ["خروج", "exit", "quit"]:
+                print("نورا: مع السلامة!")
+                break
+            elif user_input.lower() == "scan":
+                self.simulate_server_scan()
+                continue
+            elif not user_input:
+                continue
+            
+            # الحصول على الرد
+            response = self.get_response(user_input)
+            print(f"نورا: {response}")
+            
+            # حفظ في السجل
+            self.chat_history.append({"role": "user", "content": user_input})
+            self.chat_history.append({"role": "assistant", "content": response})
+            self.save_history()
+
+if __name__ == "__main__":
+    assistant = NoraAssistant()
+    assistant.chat()

autostart_config.py

@@ -0,0 +1,128 @@
+import json
+import os
+import platform
+from pathlib import Path
+
+class AutoStartManager:
+    def __init__(self, app_name="DistributedTaskSystem"):
+        self.app_name = app_name
+        self.config_file = Path.home() / f".{app_name}_autostart.json"
+        self.load_config()
+    
+    def load_config(self):
+        """تحميل إعدادات التشغيل التلقائي"""
+        try:
+            with open(self.config_file, 'r') as f:
+                self.config = json.load(f)
+        except (FileNotFoundError, json.JSONDecodeError):
+            self.config = {
+                'enabled': False,
+                'startup_script': str(Path(__file__).parent / "startup.py")
+            }
+    
+    def save_config(self):
+        """حفظ الإعدادات"""
+        with open(self.config_file, 'w') as f:
+            json.dump(self.config, f, indent=2)
+    
+    def enable_autostart(self):
+        """تفعيل التشغيل التلقائي"""
+        self.config['enabled'] = True
+        self._setup_autostart()
+        self.save_config()
+    
+    def disable_autostart(self):
+        """تعطيل التشغيل التلقائي"""
+        self.config['enabled'] = False
+        self._remove_autostart()
+        self.save_config()
+    
+    def _setup_autostart(self):
+        """إعداد التشغيل التلقائي حسب نظام التشغيل"""
+        system = platform.system()
+        
+        if system == "Windows":
+            self._setup_windows()
+        elif system == "Linux":
+            self._setup_linux()
+        elif system == "Darwin":
+            self._setup_mac()
+    
+    def _setup_windows(self):
+        """إعداد التشغيل التلقائي لـ Windows"""
+        import winreg
+        key = winreg.OpenKey(
+            winreg.HKEY_CURRENT_USER,
+            r"Software\Microsoft\Windows\CurrentVersion\Run",
+            0, winreg.KEY_SET_VALUE
+        )
+        winreg.SetValueEx(
+            key, self.app_name, 0, winreg.REG_SZ,
+            f'python "{self.config["startup_script"]}"'
+        )
+        winreg.CloseKey(key)
+    
+    def _setup_linux(self):
+        """إعداد التشغيل التلقائي لـ Linux"""
+        autostart_dir = Path.home() / ".config/autostart"
+        autostart_dir.mkdir(exist_ok=True)
+        
+        desktop_file = autostart_dir / f"{self.app_name}.desktop"
+        desktop_file.write_text(f"""
+        [Desktop Entry]
+        Type=Application
+        Name={self.app_name}
+        Exec=python3 {self.config['startup_script']}
+        Terminal=false
+        """)
+    
+    def _setup_mac(self):
+        """إعداد التشغيل التلقائي لـ macOS"""
+        plist_dir = Path.home() / "Library/LaunchAgents"
+        plist_dir.mkdir(exist_ok=True)
+        
+        plist_file = plist_dir / f"com.{self.app_name.lower()}.plist"
+        plist_file.write_text(f"""
+        <?xml version="1.0" encoding="UTF-8"?>
+        <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+        <plist version="1.0">
+        <dict>
+            <key>Label</key>
+            <string>com.{self.app_name.lower()}</string>
+            <key>ProgramArguments</key>
+            <array>
+                <string>python</string>
+                <string>{self.config['startup_script']}</string>
+            </array>
+            <key>RunAtLoad</key>
+            <true/>
+        </dict>
+        </plist>
+        """)
+    
+    def _remove_autostart(self):
+        """إزالة التشغيل التلقائي"""
+        system = platform.system()
+        
+        if system == "Windows":
+            import winreg
+            try:
+                key = winreg.OpenKey(
+                    winreg.HKEY_CURRENT_USER,
+                    r"Software\Microsoft\Windows\CurrentVersion\Run",
+                    0, winreg.KEY_SET_VALUE
+                )
+                winreg.DeleteValue(key, self.app_name)
+                winreg.CloseKey(key)
+            except WindowsError:
+                pass
+        
+        elif system == "Linux":
+            autostart_file = Path.home() / f".config/autostart/{self.app_name}.desktop"
+            if autostart_file.exists():
+                autostart_file.unlink()
+        
+        elif system == "Darwin":
+            plist_file = Path.home() / f"Library/LaunchAgents/com.{self.app_name.lower()}.plist"
+            if plist_file.exists():
+                plist_file.unlink()

background_service.py

@@ -0,0 +1,282 @@
+
+#!/usr/bin/env python3
+"""
+خدمة العمل في الخلفية - تشغيل النظام كخدمة خلفية
+يمكن التحكم بها عبر HTTP API أو إشارات النظام
+"""
+
+import os
+import sys
+import time
+import signal
+import logging
+import threading
+import subprocess
+from pathlib import Path
+from flask import Flask, jsonify, request
+import json
+from datetime import datetime
+
+class BackgroundService:
+    def __init__(self):
+        self.app = Flask(__name__)
+        self.is_running = False
+        self.services = {}
+        self.setup_routes()
+        self.setup_logging()
+        
+    def setup_logging(self):
+        """إعداد نظام السجلات"""
+        log_dir = Path("logs")
+        log_dir.mkdir(exist_ok=True)
+        
+        logging.basicConfig(
+            level=logging.INFO,
+            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+            handlers=[
+                logging.FileHandler(log_dir / 'background_service.log'),
+                logging.StreamHandler(sys.stdout)
+            ]
+        )
+        self.logger = logging.getLogger('BackgroundService')
+        
+    def setup_routes(self):
+        """إعداد مسارات HTTP API للتحكم في الخدمة"""
+        
+        @self.app.route('/status')
+        def status():
+            """حالة الخدمة"""
+            return jsonify({
+                'status': 'running' if self.is_running else 'stopped',
+                'services': {name: service['status'] for name, service in self.services.items()},
+                'uptime': time.time() - self.start_time if hasattr(self, 'start_time') else 0
+            })
+            
+        @self.app.route('/start', methods=['POST'])
+        def start_services():
+            """بدء تشغيل الخدمات"""
+            self.start_all_services()
+            return jsonify({'message': 'Services started successfully'})
+            
+        @self.app.route('/stop', methods=['POST'])
+        def stop_services():
+            """إيقاف الخدمات"""
+            self.stop_all_services()
+            return jsonify({'message': 'Services stopped successfully'})
+            
+        @self.app.route('/restart', methods=['POST'])
+        def restart_services():
+            """إعادة تشغيل الخدمات"""
+            self.stop_all_services()
+            time.sleep(2)
+            self.start_all_services()
+            return jsonify({'message': 'Services restarted successfully'})
+            
+        @self.app.route('/show-ui', methods=['POST'])
+        def show_ui():
+            """إظهار الواجهة التفاعلية"""
+            self.launch_ui()
+            return jsonify({'message': 'UI launched'})
+            
+        @self.app.route('/hide-ui', methods=['POST'])
+        def hide_ui():
+            """إخفاء الواجهة التفاعلية"""
+            self.hide_ui_windows()
+            return jsonify({'message': 'UI hidden'})
+            
+    def start_all_services(self):
+        """بدء تشغيل جميع الخدمات الخلفية"""
+        self.is_running = True
+        self.start_time = time.time()
+        
+        services_to_start = [
+            ('peer_server', 'peer_server.py'),
+            ('rpc_server', 'rpc_server.py'),
+            ('load_balancer', 'load_balancer.py'),
+            ('distributed_executor', 'main.py')
+        ]
+        
+        for service_name, script_file in services_to_start:
+            try:
+                process = subprocess.Popen(
+                    [sys.executable, script_file],
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    cwd=os.getcwd()
+                )
+                
+                self.services[service_name] = {
+                    'process': process,
+                    'status': 'running',
+                    'started_at': datetime.now().isoformat(),
+                    'script': script_file
+                }
+                
+                self.logger.info(f"✅ بدء تشغيل {service_name} (PID: {process.pid})")
+                
+            except Exception as e:
+                self.logger.error(f"❌ فشل في بدء تشغيل {service_name}: {e}")
+                self.services[service_name] = {
+                    'process': None,
+                    'status': 'failed',
+                    'error': str(e)
+                }
+                
+    def stop_all_services(self):
+        """إيقاف جميع الخدمات"""
+        self.is_running = False
+        
+        for service_name, service_info in self.services.items():
+            if service_info.get('process'):
+                try:
+                    service_info['process'].terminate()
+                    service_info['process'].wait(timeout=5)
+                    service_info['status'] = 'stopped'
+                    self.logger.info(f"🛑 تم إيقاف {service_name}")
+                except Exception as e:
+                    # إجبار الإيقاف
+                    service_info['process'].kill()
+                    self.logger.warning(f"⚠️ تم إجبار إيقاف {service_name}: {e}")
+                    
+    def launch_ui(self):
+        """تشغيل الواجهة التفاعلية عند الحاجة"""
+        try:
+            # تشغيل خادم الواجهة الأمامية
+            ui_process = subprocess.Popen(
+                ['npm', 'run', 'dev'],
+                cwd=os.getcwd(),
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE
+            )
+            
+            self.services['ui_server'] = {
+                'process': ui_process,
+                'status': 'running',
+                'started_at': datetime.now().isoformat()
+            }
+            
+            self.logger.info("🖥️ تم تشغيل الواجهة التفاعلية")
+            
+            # فتح المتصفح تلقائياً (اختياري)
+            import webbrowser
+            time.sleep(3)  # انتظار حتى يصبح الخادم جاهزاً
+            webbrowser.open('http://localhost:5173')
+            
+        except Exception as e:
+            self.logger.error(f"❌ فشل في تشغيل الواجهة التفاعلية: {e}")
+            
+    def hide_ui_windows(self):
+        """إخفاء نوافذ الواجهة التفاعلية"""
+        if 'ui_server' in self.services and self.services['ui_server'].get('process'):
+            try:
+                self.services['ui_server']['process'].terminate()
+                self.services['ui_server']['status'] = 'stopped'
+                self.logger.info("🔒 تم إخفاء الواجهة التفاعلية")
+            except Exception as e:
+                self.logger.error(f"❌ فشل في إخفاء الواجهة التفاعلية: {e}")
+                
+    def health_check_loop(self):
+        """فحص دوري لحالة الخدمات وإعادة تشغيلها عند الحاجة"""
+        while self.is_running:
+            for service_name, service_info in self.services.items():
+                if service_info.get('process') and service_info['status'] == 'running':
+                    if service_info['process'].poll() is not None:
+                        # الخدمة توقفت بشكل غير متوقع
+                        self.logger.warning(f"⚠️ الخدمة {service_name} توقفت، إعادة تشغيل...")
+                        self.restart_single_service(service_name)
+                        
+            time.sleep(30)  # فحص كل 30 ثانية
+            
+    def restart_single_service(self, service_name):
+        """إعادة تشغيل خدمة واحدة"""
+        service_info = self.services.get(service_name)
+        if not service_info:
+            return
+            
+        script_file = service_info.get('script')
+        if script_file:
+            try:
+                process = subprocess.Popen(
+                    [sys.executable, script_file],
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE
+                )
+                
+                self.services[service_name].update({
+                    'process': process,
+                    'status': 'running',
+                    'restarted_at': datetime.now().isoformat()
+                })
+                
+                self.logger.info(f"✅ تم إعادة تشغيل {service_name}")
+                
+            except Exception as e:
+                self.logger.error(f"❌ فشل في إعادة تشغيل {service_name}: {e}")
+                
+    def setup_signal_handlers(self):
+        """إعداد معالجات الإشارات للتحكم في الخدمة"""
+        def signal_handler(signum, frame):
+            self.logger.info(f"تلقي إشارة {signum}, إيقاف الخدمة...")
+            self.stop_all_services()
+            sys.exit(0)
+            
+        signal.signal(signal.SIGTERM, signal_handler)
+        signal.signal(signal.SIGINT, signal_handler)
+        
+    def run_as_daemon(self):
+        """تشغيل الخدمة كخدمة خلفية"""
+        self.logger.info("🚀 بدء تشغيل الخدمة في الخلفية...")
+        
+        # بدء الخدمات
+        self.start_all_services()
+        
+        # بدء حلقة الفحص الصحي
+        health_thread = threading.Thread(target=self.health_check_loop, daemon=True)
+        health_thread.start()
+        
+        # إعداد معالجات الإشارات
+        self.setup_signal_handlers()
+        
+        # تشغيل خادم HTTP API للتحكم
+        self.logger.info("🌐 تشغيل HTTP API على المنفذ 8888")
+        self.app.run(host='0.0.0.0', port=8888, debug=False)
+
+def main():
+    service = BackgroundService()
+    
+    if len(sys.argv) > 1:
+        command = sys.argv[1]
+        
+        if command == 'start':
+            service.run_as_daemon()
+        elif command == 'status':
+            # فحص حالة الخدمة
+            import requests
+            try:
+                response = requests.get('http://localhost:8888/status')
+                print(json.dumps(response.json(), indent=2, ensure_ascii=False))
+            except:
+                print("❌ الخدمة غير متاحة")
+        elif command == 'stop':
+            # إيقاف الخدمة
+            import requests
+            try:
+                response = requests.post('http://localhost:8888/stop')
+                print(response.json()['message'])
+            except:
+                print("❌ فشل في إيقاف الخدمة")
+        elif command == 'show-ui':
+            # إظهار الواجهة التفاعلية
+            import requests
+            try:
+                response = requests.post('http://localhost:8888/show-ui')
+                print(response.json()['message'])
+            except:
+                print("❌ فشل في إظهار الواجهة التفاعلية")
+        else:
+            print("الأوامر المتاحة: start, status, stop, show-ui")
+    else:
+        print("استخدام: python background_service.py [start|status|stop|show-ui]")
+
+if __name__ == "__main__":
+    main()

central_manager.py

@@ -0,0 +1,111 @@
+#!/usr/bin/env python3
+# central_manager.py
+
+import time
+import threading
+from typing import Dict, List
+
+import requests
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+
+# ---- إعداد FastAPI ----------------------------------------------------------
+app = FastAPI(title="Central Task Manager")
+
+# ---- نماذج البيانات --------------------------------------------------------
+
+class RegisterRequest(BaseModel):
+    """تسجيل أو تجديد ظهور العقدة."""
+    url: str          # مثلاً: "http://203.0.113.45:7520/run"
+    load: float = 0.0 # نسبة تحميل العقدة (0.0 - 1.0)، اختياري
+
+class TaskRequest(BaseModel):
+    func: str
+    args: List       = []
+    kwargs: Dict     = {}
+    complexity: float = 0.0
+
+# ---- سجلّ العقد ------------------------------------------------------------
+# بنخزّن للعقدة: آخر timestamp و load
+peers: Dict[str, Dict] = {}
+
+HEARTBEAT_TTL = 60      # ثواني قبل اعتبار العقدة متوقفة
+HEALTH_CHECK_FREQ = 30  # ثواني بين فحوص الصحة الداخلية
+
+# ---- API للعقد لتسجيل نفسها -----------------------------------------------
+
+@app.post("/register")
+async def register_peer(req: RegisterRequest):
+    """العقدة تستدعي هذه النقطة كلما انطلقت أو دورياً لتجديد ظهورها."""
+    peers[req.url] = {"last_seen": time.time(), "load": req.load}
+    return {"status": "ok", "peers_count": len(peers)}
+
+# ---- API للعمليات ---------------------------------------------------------
+
+@app.get("/peers", response_model=List[str])
+async def list_peers():
+    """يعيد قائمة بالعقد الصالحة بعد تنقية المتوقفة."""
+    now = time.time()
+    # حذف العقد المتوقفة
+    for url, info in list(peers.items()):
+        if now - info["last_seen"] > HEARTBEAT_TTL:
+            peers.pop(url)
+    return list(peers.keys())
+
+@app.post("/dispatch")
+async def dispatch_task(task: TaskRequest):
+    """يتلقى مهمة ويعيد توجيهها لأفضل عقدة أو ينفذ محليّاً."""
+    available = await list_peers()
+    if not available:
+        raise HTTPException(503, "لا توجد عقد متاحة حاليّاً")
+
+    # خوارزمية بسيطة: الاختيار بناءً على أقل تحميل معلن
+    # أو تدوير دائري إذا لم يعلن أحد عن تحميله
+    best = None
+    best_load = 1.1
+    for url in available:
+        load = peers[url].get("load", None)
+        if load is None:
+            best = url
+            break
+        if load < best_load:
+            best, best_load = url, load
+
+    if not best:
+        best = available[0]
+
+    # إعادة توجيه الطلب
+    try:
+        resp = requests.post(best, json=task.dict(), timeout=10)
+        resp.raise_for_status()
+        return resp.json()
+    except Exception as e:
+        raise HTTPException(502, f"فشل التوجيه إلى {best}: {e}")
+
+# ---- فحص دوري لصحة العقد ---------------------------------------------------
+
+def health_check_loop():
+    while True:
+        now = time.time()
+        for url in list(peers.keys()):
+            health_url = url.replace("/run", "/health")
+            try:
+                r = requests.get(health_url, timeout=3)
+                if r.status_code == 200:
+                    peers[url]["last_seen"] = now
+                    # يمكنك تحديث load من رد /health إذا وفّرته
+                else:
+                    peers.pop(url)
+            except:
+                peers.pop(url)
+        time.sleep(HEALTH_CHECK_FREQ)
+
+# ---- تشغيل الخلفيات وخادم FastAPI ------------------------------------------
+
+if __name__ == "__main__":
+    # شغل لوب الفحص الطبي في الخلفية
+    threading.Thread(target=health_check_loop, daemon=True).start()
+
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=1500)
+

components.json

@@ -0,0 +1,20 @@
+{
+    "$schema": "https://ui.shadcn.com/schema.json",
+    "style": "new-york",
+    "rsc": false,
+    "tsx": true,
+    "tailwind": {
+      "config": "tailwind.config.ts",
+      "css": "client/src/index.css",
+      "baseColor": "neutral",
+      "cssVariables": true,
+      "prefix": ""
+    },
+    "aliases": {
+      "components": "@/components",
+      "utils": "@/lib/utils",
+      "ui": "@/components/ui",
+      "lib": "@/lib",
+      "hooks": "@/hooks"
+    }
+}

control.py

@@ -0,0 +1,26 @@
+import argparse
+from autostart_config import AutoStartManager
+
+def main():
+    parser = argparse.ArgumentParser(description="نظام التحكم في التشغيل التلقائي")
+    parser.add_argument('--enable', action='store_true', help="تفعيل التشغيل التلقائي")
+    parser.add_argument('--disable', action='store_true', help="تعطيل التشغيل التلقائي")
+    parser.add_argument('--status', action='store_true', help="عرض حالة التشغيل التلقائي")
+    
+    args = parser.parse_args()
+    manager = AutoStartManager()
+    
+    if args.enable:
+        manager.enable_autostart()
+        print("✓ تم تفعيل التشغيل التلقائي")
+    elif args.disable:
+        manager.disable_autostart()
+        print("✗ تم تعطيل التشغيل التلقائي")
+    elif args.status:
+        status = "مفعل" if manager.config['enabled'] else "معطل"
+        print(f"حالة التشغيل التلقائي: {status}")
+    else:
+        parser.print_help()
+
+if __name__ == "__main__":
+    main()

dashboard.py

@@ -0,0 +1,55 @@
+# dashboard.py
+from flask import Flask, render_template, jsonify
+from peer_discovery import discover_peers
+import threading
+import time
+from typing import List, Dict
+import logging
+
+app = Flask(__name__)
+app.logger.setLevel(logging.INFO)
+
+# تهيئة قائمة الأقران
+current_peers: Dict[str, List[Dict[str, str]]] = {"local": [], "external": []}
+
+def update_peers_loop() -> None:
+    """حلقة تحديث قائمة الأقران بشكل دوري"""
+    global current_peers
+    while True:
+        try:
+            new_peers = discover_peers()
+            current_peers = new_peers
+            total_peers = len(new_peers["local"]) + len(new_peers["external"])
+            app.logger.info(f"تم تحديث قائمة الأقران: {total_peers} جهاز")
+        except Exception as e:
+            app.logger.error(f"خطأ في اكتشاف الأقران: {str(e)}")
+        time.sleep(10)
+
+@app.route("/")
+def dashboard() -> str:
+    """عرض لوحة التحكم الرئيسية"""
+    total_peers = len(current_peers["local"]) + len(current_peers["external"])
+    return render_template("dashboard.html",
+                           peers_count=total_peers,
+                           last_update=time.strftime("%Y-%m-%d %H:%M:%S"))
+
+@app.route("/api/peers")
+def get_peers() -> dict:
+    """واجهة API للحصول على قائمة الأقران"""
+    total_peers = len(current_peers["local"]) + len(current_peers["external"])
+    return jsonify({
+        "peers": current_peers,
+        "count": total_peers,
+        "status": "success"
+    })
+
+def start_background_thread() -> None:
+    """بدء خيط الخلفية لتحديث الأقران"""
+    thread = threading.Thread(target=update_peers_loop)
+    thread.daemon = True
+    thread.start()
+
+if __name__ == "__main__":
+    start_background_thread()
+    app.run(host="0.0.0.0", port=7530, debug=False)
+

distributed_executor.py

@@ -0,0 +1,155 @@
+import threading
+import queue
+import time
+import json
+from typing import Callable, Dict, List
+import socket
+from zeroconf import Zeroconf, ServiceBrowser, ServiceInfo
+import logging
+import requests
+
+logging.basicConfig(level=logging.INFO)
+
+class PeerRegistry:
+    def __init__(self):
+        self._peers = {}
+        self._zeroconf = Zeroconf()
+        self.local_node_id = socket.gethostname()
+
+    def register_service(self, name: str, port: int, load: float = 0.0):
+        service_info = ServiceInfo(
+            "_tasknode._tcp.local.",
+            f"{name}._tasknode._tcp.local.",
+            addresses=[socket.inet_aton(self._get_local_ip())],
+            port=port,
+            properties={
+                b'load': str(load).encode(),
+                b'node_id': self.local_node_id.encode()
+            },
+            server=f"{name}.local."
+        )
+        self._zeroconf.register_service(service_info)
+        logging.info(f"✅ Service registered: {name} @ {self._get_local_ip()}:{port}")
+
+    def discover_peers(self, timeout: int = 3) -> List[Dict]:
+        class Listener:
+            def __init__(self):
+                self.peers = []
+
+            def add_service(self, zc, type_, name):
+                try:
+                    info = zc.get_service_info(type_, name, timeout=3000)
+                    if info:
+                        ip = socket.inet_ntoa(info.addresses[0])
+                        peer_data = {
+                            'ip': ip,
+                            'port': info.port,
+                            'load': float(info.properties.get(b'load', b'0')),
+                            'node_id': info.properties.get(b'node_id', b'unknown').decode(),
+                            'last_seen': time.time()
+                        }
+                        if peer_data not in self.peers:
+                            self.peers.append(peer_data)
+                        logging.info(f"✅ تمت إضافة نظير جديد: {peer_data}")
+                    else:
+                        logging.warning(f"⚠️ لم يتم العثور على معلومات الخدمة: {name}")
+                except Exception as e:
+                    logging.error(f"❌ خطأ أثناء جلب معلومات الخدمة {name}: {e}")
+
+            def update_service(self, zc, type_, name):
+                self.add_service(zc, type_, name)
+
+            def remove_service(self, zc, type_, name):
+                pass  # يمكن تحسينه لاحقًا
+
+        listener = Listener()
+        ServiceBrowser(self._zeroconf, "_tasknode._tcp.local.", listener)
+        time.sleep(timeout)
+        return sorted(listener.peers, key=lambda x: x['load'])
+
+    def _get_local_ip(self) -> str:
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        try:
+            s.connect(('10.255.255.255', 1))
+            ip = s.getsockname()[0]
+        except Exception:
+            ip = '127.0.0.1'
+        finally:
+            s.close()
+        return ip
+
+
+class DistributedExecutor:
+    def __init__(self, shared_secret: str):
+        self.peer_registry = PeerRegistry()
+        self.shared_secret = shared_secret
+        self.task_queue = queue.PriorityQueue()
+        self.result_cache = {}
+        self.available_peers = []
+        self._init_peer_discovery()
+
+    def _init_peer_discovery(self):
+        def discovery_loop():
+            while True:
+                self.available_peers = self.peer_registry.discover_peers()
+                logging.info(f"✅ Discovered peers: {self.available_peers}")
+                time.sleep(10)
+
+        threading.Thread(target=discovery_loop, daemon=True).start()
+
+    def submit(self, task_func: Callable, *args, **kwargs):
+        task_id = f"{task_func.__name__}_{time.time()}"
+
+        task = {
+            'task_id': task_id,
+            'function': task_func.__name__,
+            'args': args,
+            'kwargs': kwargs,
+            'sender_id': self.peer_registry.local_node_id
+        }
+
+        if self.available_peers:
+            lan_peers = [p for p in self.available_peers if self._is_local_ip(p['ip'])]
+            wan_peers = [p for p in self.available_peers if not self._is_local_ip(p['ip'])]
+
+            if lan_peers:
+                peer = min(lan_peers, key=lambda x: x['load'])
+                logging.info(f"✅ Sending task {task_id} to LAN peer {peer['node_id']}")
+            else:
+                peer = min(wan_peers, key=lambda x: x['load'])
+                logging.info(f"✅ Sending task {task_id} to WAN peer {peer['node_id']}")
+
+            self._send_to_peer(peer, task)
+        else:
+            logging.warning("⚠️ لا توجد أجهزة متاحة - سيتم تنفيذ المهمة محلياً")
+
+    def _is_local_ip(self, ip: str) -> bool:
+        return (
+            ip.startswith('192.168.') or 
+            ip.startswith('10.') or 
+            ip.startswith('172.') or
+            ip == '127.0.0.1'
+        )
+
+    def _send_to_peer(self, peer: Dict, task: Dict):
+        try:
+            url = f"http://{peer['ip']}:{peer['port']}/run"
+            response = requests.post(url, json=task, timeout=10)
+            response.raise_for_status()
+            logging.info(f"✅ Response from peer: {response.text}")
+            return response.json()
+        except Exception as e:
+            logging.error(f"❌ فشل إرسال المهمة لـ {peer['node_id']}: {e}")
+            return None
+
+
+if __name__ == "__main__":
+    executor = DistributedExecutor("my_secret_key")
+    executor.peer_registry.register_service("node1", 7520, load=0.1)
+    print("✅ نظام توزيع المهام جاهز...")
+
+    def example_task(x):
+        return x * x
+
+    executor.submit(example_task, 5)
+

drizzle.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig } from "drizzle-kit";
+
+if (!process.env.DATABASE_URL) {
+  throw new Error("DATABASE_URL, ensure the database is provisioned");
+}
+
+export default defineConfig({
+  out: "./migrations",
+  schema: "./shared/schema.ts",
+  dialect: "postgresql",
+  dbCredentials: {
+    url: process.env.DATABASE_URL,
+  },
+});

dts_cli.py

@@ -0,0 +1,66 @@
+# dts_cli.py
+import click
+from dashboard import app
+from rpc_server import app as rpc_app
+import threading
+
+@click.group()
+def cli():
+    pass
+
+@cli.command()
+def start():
+    """بدء النظام الموزع"""
+    print("جارِ تشغيل النظام الموزع...")
+    
+    # تشغيل واجهة التحكم في خيط منفصل
+    dashboard_thread = threading.Thread(
+        target=lambda: app.run(host="0.0.0.0", port=5000)
+    )
+    dashboard_thread.daemon = True
+    dashboard_thread.start()
+    
+    # تشغيل خادم RPC
+    rpc_app.run(host="0.0.0.0", port=7520)
+
+@cli.command()
+from flask import Flask, render_template, request
+
+# ... (الكود الحالي)
+
+@flask_app.route("/")
+def home():
+    tasks = {
+        "1": ("ضرب المصفوفات", "matrix"),
+        "2": ("حساب الأعداد الأولية", "prime"),
+        "3": ("معالجة البيانات", "data"),
+    }
+    return render_template("index.html", tasks=tasks)
+
+@flask_app.route("/run_task", methods=["POST"])
+def run_task():
+    task_id = request.form.get("task_id")
+    result = None
+    
+    if task_id == "1":
+        result = matrix_multiply(500)  # استبدل بمعاملاتك الفعلية
+    elif task_id == "2":
+        result = prime_calculation(100_000)
+    elif task_id == "3":
+        result = data_processing(10_000)
+    
+    return render_template("index.html", tasks={
+        "1": ("ضرب المصفوفات", "matrix"),
+        "2": ("حساب الأعداد الأولية", "prime"),
+        "3": ("معالجة البيانات", "data"),
+    }, result=result)
+def discover():
+    """عرض الأجهزة المتصلة"""
+    from peer_discovery import discover_peers
+    peers = discover_peers()
+    print("الأجهزة المتصلة:")
+    for i, peer in enumerate(peers, 1):
+        print(f"{i}. {peer}")
+
+if __name__ == "__main__":
+    cli()

electron-package.json

@@ -0,0 +1,111 @@
+{
+  "name": "nora_distributed_system",
+  "version": "1.0.0",
+  "description": "نظام نورا الذكي الموزع",
+  "main": "electron/main.js",
+  "scripts": {
+    "electron": "electron .",
+    "build-windows": "electron-builder --win",
+    "build-mac": "electron-builder --mac",
+    "build-linux": "electron-builder --linux",
+    "build-all": "electron-builder -mwl"
+  },
+  "build": {
+    "appId": "com.nora.distributed",
+    "productName": "Nora Distributed System",
+    "directories": {
+      "output": "dist"
+    },
+    "files": [
+      "build/**/*",
+      "electron/**/*",
+      "node_modules/**/*"
+    ],
+    "win": {
+      "target": [
+        {
+          "target": "nsis",
+          "arch": [
+            "x64",
+            "ia32",
+            "arm64"
+          ]
+        },
+        {
+          "target": "portable",
+          "arch": [
+            "x64",
+            "ia32"
+          ]
+        },
+        {
+          "target": "appx",
+          "arch": [
+            "x64",
+            "ia32"
+          ]
+        }
+      ],
+      "icon": "assets/icon.ico"
+    },
+    "mac": {
+      "target": [
+        {
+          "target": "dmg",
+          "arch": [
+            "x64",
+            "arm64"
+          ]
+        },
+        {
+          "target": "zip",
+          "arch": [
+            "x64",
+            "arm64"
+          ]
+        },
+        {
+          "target": "mas",
+          "arch": [
+            "x64",
+            "arm64"
+          ]
+        }
+      ],
+      "icon": "assets/icon.icns"
+    },
+    "linux": {
+      "target": [
+        {
+          "target": "AppImage",
+          "arch": [
+            "x64",
+            "arm64"
+          ]
+        },
+        {
+          "target": "deb",
+          "arch": [
+            "x64",
+            "arm64"
+          ]
+        },
+        {
+          "target": "rpm",
+          "arch": [
+            "x64",
+            "arm64"
+          ]
+        },
+        {
+          "target": "snap",
+          "arch": [
+            "x64",
+            "arm64"
+          ]
+        }
+      ],
+      "icon": "assets/icon.png"
+    }
+  }
+}

enhanced_assistant.py

@@ -0,0 +1,312 @@
+
+import os
+import json
+import requests
+from typing import Dict, List, Optional
+from difflib import get_close_matches
+import tempfile
+from PIL import Image
+from io import BytesIO
+import re
+from datetime import datetime
+
+class EnhancedNoraAssistant:
+    def __init__(self):
+        self.knowledge_file = "knowledge_base.json"
+        self.memory_file = "global_memory.json"
+        self.learning_file = "nora_learning_data.json"
+        self.history_path = "enhanced_history.json"
+        
+        # تحميل البيانات
+        self.knowledge = self.load_knowledge()
+        self.memory = self.load_memory()
+        self.chat_history = self.load_history()
+        
+        print("✅ تم تهيئة نورا المحسنة بنجاح!")
+
+    def load_knowledge(self) -> Dict:
+        """تحميل قاعدة المعرفة"""
+        if os.path.exists(self.knowledge_file):
+            with open(self.knowledge_file, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        return {}
+
+    def save_knowledge(self):
+        """حفظ قاعدة المعرفة"""
+        with open(self.knowledge_file, 'w', encoding='utf-8') as f:
+            json.dump(self.knowledge, f, ensure_ascii=False, indent=2)
+
+    def load_memory(self) -> Dict:
+        """تحميل الذاكرة العامة"""
+        if os.path.exists(self.memory_file):
+            with open(self.memory_file, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        return {}
+
+    def save_memory(self):
+        """حفظ الذاكرة العامة"""
+        with open(self.memory_file, 'w', encoding='utf-8') as f:
+            json.dump(self.memory, f, ensure_ascii=False, indent=2)
+
+    def load_history(self) -> List[Dict]:
+        """تحميل سجل المحادثة"""
+        if os.path.exists(self.history_path):
+            try:
+                with open(self.history_path, "r", encoding="utf-8") as f:
+                    return json.load(f)
+            except:
+                return []
+        return []
+
+    def save_history(self):
+        """حفظ سجل المحادثة"""
+        with open(self.history_path, "w", encoding="utf-8") as f:
+            json.dump(self.chat_history, f, ensure_ascii=False, indent=2)
+
+    def clean_text(self, text: str) -> str:
+        """تنظيف النص"""
+        text = re.sub(r'\s+', ' ', text)
+        return text.strip()
+
+    def detect_language(self, text: str) -> str:
+        """كشف لغة النص"""
+        arabic_chars = re.compile('[\u0600-\u06FF]')
+        if arabic_chars.search(text):
+            return "ar"
+        return "en"
+
+    def fix_url(self, url: str) -> str:
+        """تصحيح الرابط"""
+        if not url.startswith(("http://", "https://")):
+            return "https://" + url.lstrip("//")
+        return url
+
+    def detect_media_type(self, url: str) -> str:
+        """تحديد نوع الوسائط"""
+        url = url.lower()
+        if url.endswith(('.jpg', '.jpeg', '.png', '.gif', '.webp')):
+            return 'image'
+        elif url.endswith(('.mp4', '.mov', '.avi', '.webm')):
+            return 'video'
+        elif url.endswith(('.mp3', '.wav', '.ogg', '.m4a')):
+            return 'audio'
+        elif url.endswith('.pdf'):
+            return 'pdf'
+        return 'link'
+
+    def analyze_image_from_url(self, image_url: str) -> str:
+        """تحليل صورة من رابط"""
+        try:
+            response = requests.get(image_url, timeout=10)
+            response.raise_for_status()
+            image = Image.open(BytesIO(response.content))
+            return f"تحليل الصورة: الحجم {image.size}، الصيغة {image.format}"
+        except Exception as e:
+            return f"خطأ في تحليل الصورة: {str(e)}"
+
+    def smart_auto_reply(self, message: str) -> Optional[str]:
+        """ردود ذكية تلقائية"""
+        msg = message.strip().lower()
+        
+        responses = {
+            "هل نبدأ": "نعم ابدأ",
+            "ابدأ": "نعم ابدأ", 
+            "نعم أو لا": "نعم",
+            "هل تود": "نعم",
+            "هل تريدني": "نعم",
+            "ما هي": "ليس الآن",
+            "تفصيل": "ليس الآن",
+            "هل تحتاج": "نعم، شرح أكثر",
+            "جاهز؟": "ابدأ",
+            "قول لي": "موافق"
+        }
+        
+        for key, value in responses.items():
+            if key in msg:
+                return value
+                
+        if " أو " in msg:
+            return msg.split(" أو ")[0]
+            
+        return None
+
+    def learn_new_info(self, topic: str, info: str) -> str:
+        """تعلم معلومة جديدة"""
+        if topic not in self.knowledge:
+            self.knowledge[topic] = []
+        
+        if info not in self.knowledge[topic]:
+            self.knowledge[topic].append({
+                "content": info,
+                "timestamp": datetime.utcnow().isoformat()
+            })
+            self.save_knowledge()
+            return f"✅ تمت إضافة معلومة جديدة عن '{topic}'"
+        
+        return f"ℹ️ المعلومة موجودة مسبقاً عن '{topic}'"
+
+    def search_knowledge(self, query: str) -> str:
+        """البحث في قاعدة المعرفة"""
+        query_clean = query.strip().lower()
+        
+        # بحث مباشر
+        if query_clean in self.knowledge:
+            info = self.knowledge[query_clean]
+            if isinstance(info, list) and info:
+                return info[-1].get("content", str(info[-1]))
+            return str(info)
+        
+        # بحث في المواضيع
+        for topic, infos in self.knowledge.items():
+            if query_clean in topic.lower():
+                if isinstance(infos, list) and infos:
+                    return f"وجدت معلومة عن '{topic}': {infos[-1].get('content', str(infos[-1]))}"
+                return f"وجدت معلومة عن '{topic}': {str(infos)}"
+        
+        return None
+
+    def generate_reply(self, user_input: str) -> str:
+        """إنتاج الرد الذكي"""
+        user_input = self.clean_text(user_input)
+        
+        # فحص الردود التلقائية الذكية
+        auto_reply = self.smart_auto_reply(user_input)
+        if auto_reply:
+            self.memory[user_input] = auto_reply
+            self.save_memory()
+            return auto_reply
+
+        # فحص الذاكرة
+        if user_input in self.memory:
+            return self.memory[user_input]
+
+        # البحث في المطابقات القريبة
+        matches = get_close_matches(user_input, self.memory.keys(), n=1, cutoff=0.6)
+        if matches:
+            return self.memory[matches[0]]
+
+        # البحث في قاعدة المعرفة
+        knowledge_result = self.search_knowledge(user_input)
+        if knowledge_result:
+            self.memory[user_input] = knowledge_result
+            self.save_memory()
+            return knowledge_result
+
+        # معالجة الروابط
+        if user_input.startswith("http://") or user_input.startswith("https://"):
+            return self.handle_url(user_input)
+
+        # تصحيح الروابط في النص
+        if '//' in user_input:
+            corrected_url = self.fix_url(user_input)
+            reply = f"تم تصحيح الرابط: {corrected_url}"
+        else:
+            # رد افتراضي مع تعلم
+            reply = f"شكراً لك على الرسالة: '{user_input}'. سأتذكر هذا للمرة القادمة."
+            
+            # تعلم تلقائي
+            if len(user_input.split()) > 2:  # إذا كانت جملة معقولة
+                self.learn_new_info("محادثات_عامة", user_input)
+
+        # حفظ في الذاكرة
+        self.memory[user_input] = reply
+        self.save_memory()
+        return reply
+
+    def handle_url(self, url: str) -> str:
+        """معالجة الروابط"""
+        url = self.fix_url(url)
+        media_type = self.detect_media_type(url)
+        
+        if media_type == 'image':
+            analysis = self.analyze_image_from_url(url)
+            reply = f"🖼️ صورة تم تحليلها:\n{analysis}"
+        elif media_type == 'video':
+            reply = f"🎥 فيديو تم اكتشافه: {url}"
+        elif media_type == 'audio':
+            reply = f"🎵 ملف صوتي تم اكتشافه: {url}"
+        elif media_type == 'pdf':
+            reply = f"📄 ملف PDF تم اكتشافه: {url}"
+        else:
+            reply = f"🔗 رابط ويب: {url}"
+        
+        return reply
+
+    def simulate_server_scan(self):
+        """محاكاة البحث عن الخوادم"""
+        print("نورا: أبحث عن خوادم متاحة...")
+        fake_servers = ["server-01.cloud.com", "server-02.cloud.com", "server-03.local"]
+        
+        for server in fake_servers:
+            print(f"نورا: تم العثور على خادم: {server}")
+            print(f"نورا: أقوم بمحاكاة النسخ إلى {server}...")
+        
+        return "تمت عملية المحاكاة بنجاح ✅"
+
+    def get_stats(self) -> Dict:
+        """إحصائيات النظام"""
+        return {
+            "معرفة_محفوظة": len(self.knowledge),
+            "ذكريات": len(self.memory),
+            "سجل_محادثات": len(self.chat_history),
+            "آخر_تحديث": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        }
+
+    def chat(self):
+        """بدء المحادثة التفاعلية"""
+        print("🤖 مرحباً! أنا نورا المحسنة، مساعدتك الذكية.")
+        print("📚 لدي قدرات محسنة في التعلم الذاتي وتحليل الوسائط")
+        print("💡 اكتب 'خروج' للإنهاء، 'إحصائيات' لعرض الإحص��ئيات، 'scan' للبحث عن خوادم")
+        print("-" * 50)
+        
+        while True:
+            try:
+                user_input = input("\n🧑 أنت: ").strip()
+                
+                if user_input.lower() in ["خروج", "exit", "quit"]:
+                    print("نورا: مع السلامة! 👋")
+                    break
+                
+                elif user_input.lower() == "إحصائيات":
+                    stats = self.get_stats()
+                    print("📊 إحصائيات النظام:")
+                    for key, value in stats.items():
+                        print(f"   {key}: {value}")
+                    continue
+                
+                elif user_input.lower() == "scan":
+                    result = self.simulate_server_scan()
+                    print(f"نورا: {result}")
+                    continue
+                
+                elif not user_input:
+                    continue
+                
+                # الحصول على الرد
+                response = self.generate_reply(user_input)
+                print(f"🤖 نورا: {response}")
+                
+                # حفظ في السجل
+                self.chat_history.append({
+                    "user": user_input,
+                    "assistant": response,
+                    "timestamp": datetime.utcnow().isoformat()
+                })
+                
+                # حفظ السجل كل 5 رسائل
+                if len(self.chat_history) % 5 == 0:
+                    self.save_history()
+                    
+            except KeyboardInterrupt:
+                print("\n\nنورا: تم إيقاف المحادثة. مع السلامة! 👋")
+                break
+            except Exception as e:
+                print(f"نورا: عذراً، حدث خطأ: {str(e)}")
+
+def main():
+    """تشغيل المساعد المحسن"""
+    assistant = EnhancedNoraAssistant()
+    assistant.chat()
+
+if __name__ == "__main__":
+    main()

global_memory.json

@@ -0,0 +1,3 @@
+{
+  "مرحبا": "شكراً لك على الرسالة: 'مرحبا'. سأتذكر هذا للمرة القادمة."
+}

history.json

@@ -0,0 +1,26 @@
+[
+  {
+    "role": "user",
+    "content": "اه"
+  },
+  {
+    "role": "assistant",
+    "content": "عذراً، حدث خطأ: 401"
+  },
+  {
+    "role": "user",
+    "content": "مرحبا"
+  },
+  {
+    "role": "assistant",
+    "content": "عذراً، حدث خطأ: 401"
+  },
+  {
+    "role": "user",
+    "content": "مم"
+  },
+  {
+    "role": "assistant",
+    "content": "عذراً، حدث خطأ: 401"
+  }
+]

index.html

@@ -0,0 +1,85 @@
+<!DOCTYPE html>
+<html lang="ar" dir="rtl">
+<head>
+    <meta charset="UTF-8">
+    <title>نظام توزيع المهام الذكي</title>
+    <style>
+        body {
+            font-family: Arial, sans-serif;
+            max-width: 800px;
+            margin: 0 auto;
+            padding: 20px;
+            background-color: #f5f5f5;
+        }
+        h1 {
+            color: #2c3e50;
+            text-align: center;
+        }
+        ul {
+            list-style: none;
+            padding: 0;
+        }
+        li {
+            background: white;
+            margin: 10px 0;
+            padding: 15px;
+            border-radius: 5px;
+            box-shadow: 0 2px 5px rgba(0,0,0,0.1);
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+        button {
+            background: #3498db;
+            color: white;
+            border: none;
+            padding: 8px 15px;
+            border-radius: 3px;
+            cursor: pointer;
+        }
+        button:hover {
+            background: #2980b9;
+        }
+        #result {
+            background: white;
+            padding: 15px;
+            border-radius: 5px;
+            margin-top: 20px;
+        }
+    </style>
+</head>
+<body>
+    <h1>🚀 نظام توزيع المهام الذكي</h1>
+    <ul id="tasks">
+        {% for task_id, task in tasks.items() %}
+        <li>
+            <span>{{ task[0] }}</span>
+            <button onclick="runTask('{{ task_id }}')">تشغيل</button>
+        </li>
+        {% endfor %}
+    </ul>
+
+    <div id="result" style="display: {% if result %}block{% else %}none{% endif %};">
+        <h2>✅ النتيجة:</h2>
+        <pre>{{ result }}</pre>
+    </div>
+
+    <script>
+        async function runTask(taskId) {
+            const response = await fetch("/run_task", {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/x-www-form-urlencoded",
+                },
+                body: `task_id=${taskId}`
+            });
+            const data = await response.text();
+            
+            // تحديث الصفحة دون إعادة تحميل كاملة
+            document.getElementById("result").innerHTML = 
+                `<h2>✅ النتيجة:</h2><pre>${JSON.parse(data).result}</pre>`;
+            document.getElementById("result").style.display = "block";
+        }
+    </script>
+</body>
+</html>

internet_scanner.py

@@ -0,0 +1,165 @@
+
+"""
+internet_scanner.py - ماسح للبحث عن أجهزة DTS على الإنترنت
+"""
+import requests
+import threading
+import time
+import socket
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import logging
+
+class InternetScanner:
+    def __init__(self):
+        self.discovered_peers = set()
+        self.scan_ranges = [
+            # نطاقات IP شائعة للخوادم العامة
+            "8.8.8.0/24",      # Google DNS range
+            "1.1.1.0/24",      # Cloudflare range
+            "208.67.222.0/24", # OpenDNS range
+        ]
+        
+    def scan_ip_range(self, ip_range: str, port: int = 7520):
+        """مسح نطاق IP للبحث عن خوادم DTS"""
+        import ipaddress
+        
+        try:
+            network = ipaddress.ip_network(ip_range, strict=False)
+            active_peers = []
+            
+            with ThreadPoolExecutor(max_workers=50) as executor:
+                futures = []
+                
+                for ip in network.hosts():
+                    future = executor.submit(self.check_dts_node, str(ip), port)
+                    futures.append(future)
+                
+                for future in as_completed(futures, timeout=30):
+                    try:
+                        result = future.result()
+                        if result:
+                            active_peers.append(result)
+                    except:
+                        continue
+                        
+            return active_peers
+            
+        except Exception as e:
+            logging.error(f"خطأ في مسح النطاق {ip_range}: {e}")
+            return []
+    
+    def check_dts_node(self, ip: str, port: int = 7520) -> str:
+        """فحص IP معين للتأكد من وجود خادم DTS مع المشروع"""
+        try:
+            # فحص صفحة الصحة العامة
+            health_url = f"http://{ip}:{port}/health"
+            response = requests.get(health_url, timeout=2)
+            
+            if response.status_code == 200:
+                # فحص وجود المشروع الصحيح
+                run_url = f"http://{ip}:{port}/run"
+                
+                # اختبار مهمة من المشروع للتأكد
+                test_payload = {
+                    "func": "matrix_multiply",
+                    "args": [2],
+                    "kwargs": {}
+                }
+                
+                test_response = requests.post(run_url, json=test_payload, timeout=3)
+                
+                # فحص إضافي للتأكد من هوية المشروع
+                project_check = requests.get(f"http://{ip}:{port}/project_info", timeout=2)
+                
+                if (test_response.status_code in [200, 404] and 
+                    project_check.status_code == 200):
+                    
+                    project_data = project_check.json()
+                    
+                    # التحقق من معرف المشروع الصحيح
+                    if (project_data.get("project_name") == "distributed-task-system" and
+                        project_data.get("version") == "1.0"):
+                        logging.info(f"✅ اكتُشف خادم DTS صحيح: {ip}:{port}")
+                        return run_url
+                    else:
+                        logging.warning(f"⚠️ خادم على {ip}:{port} لكن مشروع مختلف")
+                        
+        except:
+            pass
+        return None
+    
+    def scan_public_repositories(self):
+        """البحث في المستودعات العامة عن عناوين خوادم DTS"""
+        try:
+            # البحث في GitHub عن مشاريع DTS
+            github_api = "https://api.github.com/search/repositories"
+            params = {
+                "q": "distributed task system port:7520",
+                "sort": "updated",
+                "per_page": 10
+            }
+            
+            response = requests.get(github_api, params=params, timeout=10)
+            if response.status_code == 200:
+                repos = response.json().get("items", [])
+                
+                for repo in repos:
+                    # محاولة استخراج IPs من وصف المشروع أو README
+                    if repo.get("description"):
+                        self.extract_ips_from_text(repo["description"])
+                        
+        except Exception as e:
+            logging.warning(f"خطأ في البحث في المستودعات: {e}")
+    
+    def extract_ips_from_text(self, text: str):
+        """استخراج عناوين IP من النص"""
+        import re
+        
+        ip_pattern = r'\b(?:[0-9]{1,3}\.){3}[0-9]{1,3}\b'
+        ips = re.findall(ip_pattern, text)
+        
+        for ip in ips:
+            try:
+                # التحقق من صحة IP
+                socket.inet_aton(ip)
+                peer_url = f"http://{ip}:7520/run"
+                
+                # فحص سريع
+                if self.check_dts_node(ip):
+                    self.discovered_peers.add(peer_url)
+                    
+            except:
+                continue
+    
+    def start_continuous_scan(self):
+        """بدء المسح المستمر"""
+        def scan_loop():
+            while True:
+                try:
+                    # مسح النطاقات المحددة
+                    for ip_range in self.scan_ranges:
+                        peers = self.scan_ip_range(ip_range)
+                        for peer in peers:
+                            self.discovered_peers.add(peer)
+                    
+                    # البحث في المستودعات العامة
+                    self.scan_public_repositories()
+                    
+                    logging.info(f"اكتُشف {len(self.discovered_peers)} خادم على الإنترنت")
+                    
+                except Exception as e:
+                    logging.error(f"خطأ في المسح المستمر: {e}")
+                
+                # انتظار 30 دقيقة قبل المسح التالي
+                time.sleep(1800)
+        
+        thread = threading.Thread(target=scan_loop, daemon=True)
+        thread.start()
+        logging.info("🔍 بدء المسح المستمر للإنترنت")
+    
+    def get_discovered_peers(self):
+        """الحصول على قائمة الأجهزة المكتشفة"""
+        return list(self.discovered_peers)
+
+# إنشاء مثيل عام
+internet_scanner = InternetScanner()

launcher.py

@@ -0,0 +1,215 @@
+
+#!/usr/bin/env python3
+"""
+مشغل موحد لنظام توزيع المهام
+يوفر خيارات متعددة للتشغيل
+"""
+
+import sys
+import os
+import subprocess
+import argparse
+import time
+from pathlib import Path
+
+def check_requirements():
+    """فحص المتطلبات والاعتماديات"""
+    required_files = [
+        'background_service.py',
+        'main.py',
+        'peer_server.py',
+        'rpc_server.py',
+        'load_balancer.py'
+    ]
+    
+    missing_files = []
+    for file in required_files:
+        if not Path(file).exists():
+            missing_files.append(file)
+            
+    if missing_files:
+        print(f"❌ ملفات مفقودة: {', '.join(missing_files)}")
+        return False
+        
+    return True
+
+def install_tray_dependencies():
+    """تثبيت اعتماديات أيقونة شريط النظام"""
+    try:
+        subprocess.check_call([sys.executable, '-m', 'pip', 'install', 'pystray', 'Pillow'])
+        print("✅ تم تثبيت اعتماديات أيقونة شريط النظام")
+        return True
+    except subprocess.CalledProcessError:
+        print("❌ فشل في تثبيت اعتماديات أيقونة شريط النظام")
+        return False
+
+def start_background_service():
+    """بدء تشغيل الخدمة في الخلفية"""
+    print("🚀 بدء تشغيل الخدمة في الخلفية...")
+    
+    # تشغيل الخدمة الخلفية
+    process = subprocess.Popen(
+        [sys.executable, 'background_service.py', 'start'],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE
+    )
+    
+    # انتظار قليل للتأكد من بدء التشغيل
+    time.sleep(2)
+    
+    if process.poll() is None:
+        print("✅ تم بدء تشغيل الخدمة الخلفية بنجاح")
+        return process
+    else:
+        print("❌ فشل في بدء تشغيل الخدمة الخلفية")
+        return None
+
+def start_with_tray():
+    """تشغيل النظام مع أيقونة شريط النظام"""
+    print("🖱️ تشغيل النظام مع أيقونة شريط النظام...")
+    
+    # بدء الخدمة الخلفية أولاً
+    bg_process = start_background_service()
+    if not bg_process:
+        return False
+        
+    time.sleep(3)  # انتظار حتى تصبح الخدمة جاهزة
+    
+    try:
+        # تشغيل أيقونة شريط النظام
+        subprocess.run([sys.executable, 'system_tray.py'])
+    except KeyboardInterrupt:
+        print("\n🛑 إيقاف النظام...")
+        # إيقاف الخدمة الخلفية
+        try:
+            import requests
+            requests.post('http://localhost:8888/stop', timeout=5)
+        except:
+            bg_process.terminate()
+            
+    return True
+
+def start_interactive():
+    """تشغيل النظام في الوضع التفاعلي"""
+    print("🖥️ تشغيل النظام في الوضع التفاعلي...")
+    
+    # بدء الخدمة الخلفية
+    bg_process = start_background_service()
+    if not bg_process:
+        return False
+        
+    time.sleep(3)
+    
+    # تشغيل الواجهة التفاعلية
+    try:
+        import requests
+        requests.post('http://localhost:8888/show-ui', timeout=5)
+        print("✅ تم تشغيل الواجهة التفاعلية")
+        
+        # فتح المتصفح
+        import webbrowser
+        time.sleep(2)
+        webbrowser.open('http://localhost:5173')
+        
+        # انتظار إنهاء المستخدم
+        input("اضغط Enter لإيقاف النظام...")
+        
+    except KeyboardInterrupt:
+        pass
+    finally:
+        print("🛑 إيقاف النظام...")
+        try:
+            import requests
+            requests.post('http://localhost:8888/stop', timeout=5)
+        except:
+            bg_process.terminate()
+            
+    return True
+
+def start_headless():
+    """تشغيل النظام بدون واجهة (للخوادم)"""
+    print("⚙️ تشغيل النظام بدون واجهة...")
+    
+    try:
+        # تشغيل الخدمة الخلفية والانتظار
+        subprocess.run([sys.executable, 'background_service.py', 'start'])
+    except KeyboardInterrupt:
+        print("\n🛑 إيقاف النظام...")
+        
+    return True
+
+def show_status():
+    """عرض حالة النظام"""
+    subprocess.run([sys.executable, 'background_service.py', 'status'])
+
+def stop_system():
+    """إيقاف النظام"""
+    subprocess.run([sys.executable, 'background_service.py', 'stop'])
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="مشغل نظام توزيع المهام الذكي",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+أمثلة الاستخدام:
+  python launcher.py --tray           # تشغيل مع أيقونة شريط ��لنظام
+  python launcher.py --interactive    # تشغيل تفاعلي مع واجهة
+  python launcher.py --headless       # تشغيل بدون واجهة (للخوادم)
+  python launcher.py --status         # عرض حالة النظام
+  python launcher.py --stop           # إيقاف النظام
+        """
+    )
+    
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument('--tray', action='store_true', 
+                      help='تشغيل مع أيقونة شريط النظام')
+    group.add_argument('--interactive', action='store_true',
+                      help='تشغيل تفاعلي مع واجهة')
+    group.add_argument('--headless', action='store_true',
+                      help='تشغيل بدون واجهة (للخوادم)')
+    group.add_argument('--status', action='store_true',
+                      help='عرض حالة النظام')
+    group.add_argument('--stop', action='store_true',
+                      help='إيقاف النظام')
+    
+    parser.add_argument('--install-deps', action='store_true',
+                       help='تثبيت الاعتماديات المطلوبة')
+    
+    args = parser.parse_args()
+    
+    # فحص المتطلبات
+    if not check_requirements():
+        return 1
+        
+    # تثبيت الاعتماديات إذا طُلب ذلك
+    if args.install_deps:
+        install_tray_dependencies()
+        return 0
+        
+    # تنفيذ الأمر المطلوب
+    if args.status:
+        show_status()
+    elif args.stop:
+        stop_system()
+    elif args.headless:
+        success = start_headless()
+    elif args.interactive:
+        success = start_interactive()
+    elif args.tray:
+        # تثبيت اعتماديات أيقونة شريط النظام إذا لم تكن موجودة
+        try:
+            import pystray
+        except ImportError:
+            print("📦 تثبيت اعتماديات أيقونة شريط النظام...")
+            if not install_tray_dependencies():
+                print("❌ فشل في تثبيت الاعتماديات، التشغيل في الوضع التفاعلي...")
+                success = start_interactive()
+            else:
+                success = start_with_tray()
+        else:
+            success = start_with_tray()
+    
+    return 0 if success else 1
+
+if __name__ == "__main__":
+    sys.exit(main())

live_streaming.py

@@ -0,0 +1,405 @@
+
+# live_streaming.py - نظام البث المباشر للألعاب والفيديو
+
+import cv2
+import numpy as np
+import time
+import threading
+import logging
+import asyncio
+import base64
+import json
+from datetime import datetime
+from processor_manager import should_offload
+from remote_executor import execute_remotely
+from functools import wraps
+
+logging.basicConfig(level=logging.INFO)
+
+class LiveStreamManager:
+    def __init__(self):
+        self.active_streams = {}
+        self.processing_nodes = []
+        self.load_balancer = StreamLoadBalancer()
+        
+    def register_processing_node(self, node_id, capabilities):
+        """تسجيل عقدة معالجة جديدة"""
+        self.processing_nodes.append({
+            "id": node_id,
+            "capabilities": capabilities,
+            "load": 0.0,
+            "last_ping": datetime.now()
+        })
+        logging.info(f"📡 تم تسجيل عقدة معالجة: {node_id}")
+
+class StreamLoadBalancer:
+    def __init__(self):
+        self.node_loads = {}
+        
+    def get_best_node(self, task_type, nodes):
+        """اختيار أفضل عقدة للمعالجة"""
+        suitable_nodes = [n for n in nodes if task_type in n.get("capabilities", [])]
+        if not suitable_nodes:
+            return None
+        return min(suitable_nodes, key=lambda x: x["load"])
+
+def stream_offload(func):
+    """ديكوراتور خاص بالبث المباشر"""
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        complexity = estimate_stream_complexity(func, args, kwargs)
+        
+        if complexity > 70 or should_offload(complexity):
+            logging.info(f"📺 إرسال مهمة البث {func.__name__} للمعالجة الموزعة")
+            return execute_remotely(func.__name__, args, kwargs)
+        
+        logging.info(f"📺 معالجة البث محلياً: {func.__name__}")
+        return func(*args, **kwargs)
+    return wrapper
+
+def estimate_stream_complexity(func, args, kwargs):
+    """تقدير تعقيد معالجة البث"""
+    if func.__name__ == "process_game_stream":
+        return args[1] * args[2] / 10000  # FPS × الدقة
+    elif func.__name__ == "real_time_video_enhancement":
+        return args[0] * 20  # عدد التحسينات × 20
+    elif func.__name__ == "multi_stream_processing":
+        return len(args[0]) * 25  # عدد البثوث × 25
+    elif func.__name__ == "ai_commentary_generation":
+        return args[1] * 15  # طول النص × 15
+    return 40
+
+# ═══════════════════════════════════════════════════════════════
+# معالجة بث الألعاب المباشر
+# ═══════════════════════════════════════════════════════════════
+
+@stream_offload
+def process_game_stream(stream_data, fps, resolution, enhancements=None):
+    """معالجة بث الألعاب في الوقت الفعلي"""
+    start_time = time.time()
+    
+    if enhancements is None:
+        enhancements = ["noise_reduction", "color_enhancement"]
+    
+    logging.info(f"🎮 معالجة بث الألعاب - FPS: {fps}, الدقة: {resolution}")
+    logging.info(f"🔧 التحسينات: {enhancements}")
+    
+    # محاكاة معالجة الإطارات
+    frame_count = len(stream_data) if isinstance(stream_data, list) else 60
+    processing_per_frame = 0.01 + (len(enhancements) * 0.005)
+    total_processing_time = frame_count * processing_per_frame
+    
+    # محاكاة المعالجة
+    time.sleep(min(total_processing_time, 2))
+    
+    # حساب جودة البث
+    quality_score = min(100, 60 + (len(enhancements) * 8) + (fps / 2))
+    latency = max(50, 200 - (fps * 2))  # أقل تأخير مع FPS أعلى
+    
+    result = {
+        "status": "success",
+        "stream_type": "game",
+        "fps_processed": fps,
+        "resolution": resolution,
+        "frames_processed": frame_count,
+        "enhancements_applied": enhancements,
+        "quality_score": round(quality_score, 1),
+        "latency_ms": latency,
+        "processing_time": time.time() - start_time,
+        "bandwidth_optimized": True
+    }
+    
+    logging.info(f"✅ تمت معالجة بث اللعبة - جودة: {result['quality_score']}%")
+    return result
+
+@stream_offload
+def real_time_video_enhancement(enhancement_types, video_quality="1080p", target_fps=60):
+    """تحسين الفيديو في الوقت الفعلي"""
+    start_time = time.time()
+    
+    available_enhancements = {
+        "upscaling": "تحسين الدقة",
+        "noise_reduction": "إزالة التشويش",
+        "color_grading": "تصحيح الألوان",
+        "motion_smoothing": "تنعيم الحركة",
+        "hdr_enhancement": "تحسين HDR",
+        "sharpening": "زيادة الحدة",
+        "stabilization": "تثبيت الصورة"
+    }
+    
+    quality_multiplier = {"720p": 1, "1080p": 2, "1440p": 3, "4K": 5}
+    multiplier = quality_multiplier.get(video_quality, 2)
+    
+    processing_time = len(enhancement_types) * multiplier * target_fps * 0.0001
+    
+    logging.info(f"📹 تحسين الفيديو المباشر - الجودة: {video_quality}")
+    logging.info(f"🎯 التحسينات: {enhancement_types}")
+    
+    # محاكاة التحسين
+    time.sleep(min(processing_time, 1.5))
+    
+    enhancements_applied = {}
+    for enhancement in enhancement_types:
+        if enhancement in available_enhancements:
+            enhancements_applied[enhancement] = {
+                "name": available_enhancements[enhancement],
+                "improvement": round(np.random.uniform(15, 35), 1),
+                "processing_cost": round(processing_time / len(enhancement_types), 4)
+            }
+    
+    result = {
+        "status": "success",
+        "video_quality": video_quality,
+        "target_fps": target_fps,
+        "enhancements": enhancements_applied,
+        "total_improvement": round(np.mean([e["improvement"] for e in enhancements_applied.values()]), 1),
+        "processing_time": time.time() - start_time,
+        "real_time_capable": processing_time < (1/target_fps)
+    }
+    
+    logging.info(f"✅ تم تحسين الفيديو - تحسن: {result['total_improvement']}%")
+    return result
+
+# ═══════════════════════════════════════════════════════════════
+# معالجة متعددة البثوث
+# ═══════════════════════════════════════════════════════════════
+
+@stream_offload
+def multi_stream_processing(streams_data, processing_mode="parallel"):
+    """معالجة عدة بثوث في نفس الوقت"""
+    start_time = time.time()
+    
+    logging.info(f"📡 معالجة متعددة البثوث - العدد: {len(streams_data)}")
+    logging.info(f"⚙️ وضع المعالجة: {processing_mode}")
+    
+    results = {}
+    
+    if processing_mode == "parallel":
+        # محاكاة المعالجة المتوازية
+        max_processing_time = max([s.get("complexity", 1) for s in streams_data]) * 0.1
+        time.sleep(min(max_processing_time, 2))
+        
+        for i, stream in enumerate(streams_data):
+            stream_id = f"stream_{i+1}"
+            results[stream_id] = {
+                "status": "processed",
+                "quality": stream.get("quality", "1080p"),
+                "fps": stream.get("fps", 30),
+                "enhancement_applied": True,
+                "processing_node": f"node_{(i % 3) + 1}"  # توزيع على 3 عقد
+            }
+    else:
+        # معالجة تسلسلية
+        total_time = sum([s.get("complexity", 1) for s in streams_data]) * 0.05
+        time.sleep(min(total_time, 3))
+        
+        for i, stream in enumerate(streams_data):
+            stream_id = f"stream_{i+1}"
+            results[stream_id] = {
+                "status": "processed",
+                "quality": stream.get("quality", "1080p"),
+                "fps": stream.get("fps", 30),
+                "processing_order": i + 1
+            }
+    
+    result = {
+        "status": "success",
+        "streams_processed": len(streams_data),
+        "processing_mode": processing_mode,
+        "results": results,
+        "total_processing_time": time.time() - start_time,
+        "average_quality": round(np.mean([30, 45, 60, 55]), 1),  # محاكاة متوسط الجودة
+        "nodes_utilized": len(set([r.get("processing_node", "main") for r in results.values()]))
+    }
+    
+    logging.info(f"✅ تمت معالجة {len(streams_data)} بث - العقد المستخدمة: {result['nodes_utilized']}")
+    return result
+
+# ═══════════════════════════════════════════════════════════════
+# ذكاء اصطناعي للبث
+# ═══════════════════════════════════════════════════════════════
+
+@stream_offload
+def ai_commentary_generation(game_events, commentary_length, language="ar"):
+    """توليد تعليق ذكي للألعاب"""
+    start_time = time.time()
+    
+    logging.info(f"🤖 توليد تعليق ذكي - الطول: {commentary_length} كلمة")
+    
+    # قوالب التعليق
+    commentary_templates = {
+        "ar": [
+            "حركة رائعة من اللاعب!",
+            "هذا هدف مذهل!",
+            "دفاع قوي في هذه اللحظة",
+            "استراتيجية مم��ازة",
+            "أداء استثنائي!"
+        ],
+        "en": [
+            "Amazing move by the player!",
+            "What a fantastic goal!",
+            "Strong defense right there",
+            "Excellent strategy",
+            "Outstanding performance!"
+        ]
+    }
+    
+    processing_time = commentary_length * 0.02  # 0.02 ثانية لكل كلمة
+    time.sleep(min(processing_time, 1))
+    
+    # توليد التعليق
+    templates = commentary_templates.get(language, commentary_templates["ar"])
+    generated_commentary = []
+    
+    for i in range(min(commentary_length // 5, len(game_events))):
+        template = np.random.choice(templates)
+        generated_commentary.append(template)
+    
+    result = {
+        "status": "success",
+        "language": language,
+        "commentary_length": len(generated_commentary),
+        "generated_text": generated_commentary,
+        "game_events_analyzed": len(game_events),
+        "processing_time": time.time() - start_time,
+        "emotion_detection": "excited",  # محاكاة كشف المشاعر
+        "context_awareness": True
+    }
+    
+    logging.info(f"✅ تم توليد التعليق - {len(generated_commentary)} جملة")
+    return result
+
+@stream_offload
+def stream_quality_optimization(stream_metadata, target_bandwidth, viewer_count):
+    """تحسين جودة البث حسب النطاق الترددي وعدد المشاهدين"""
+    start_time = time.time()
+    
+    logging.info(f"📊 تحسين جودة البث - المشاهدين: {viewer_count}")
+    logging.info(f"🌐 النطاق المستهدف: {target_bandwidth} Mbps")
+    
+    # حساب الجودة المثلى
+    base_quality = min(target_bandwidth * 200, 1080)  # حد أقصى 1080p
+    
+    # تعديل حسب عدد المشاهدين
+    if viewer_count > 1000:
+        quality_adjustment = 0.8  # تقليل الجودة للأعداد الكبيرة
+    elif viewer_count > 100:
+        quality_adjustment = 0.9
+    else:
+        quality_adjustment = 1.0
+    
+    optimized_quality = int(base_quality * quality_adjustment)
+    
+    # تحديد FPS مناسب
+    if optimized_quality >= 1080:
+        optimal_fps = 60
+    elif optimized_quality >= 720:
+        optimal_fps = 45
+    else:
+        optimal_fps = 30
+    
+    time.sleep(0.5)  # محاكاة المعالجة
+    
+    result = {
+        "status": "success",
+        "original_quality": stream_metadata.get("quality", "1080p"),
+        "optimized_quality": f"{optimized_quality}p",
+        "optimal_fps": optimal_fps,
+        "target_bandwidth": target_bandwidth,
+        "viewer_count": viewer_count,
+        "bandwidth_saved": round(max(0, (1080 - optimized_quality) / 1080 * 100), 1),
+        "processing_time": time.time() - start_time,
+        "adaptive_streaming": True
+    }
+    
+    logging.info(f"✅ تم تحسين البث - الجودة: {result['optimized_quality']}")
+    return result
+
+# ═══════════════════════════════════════════════════════════════
+# إدارة البث المباشر
+# ═══════════════════════════════════════════════════════════════
+
+class LiveStreamCoordinator:
+    def __init__(self):
+        self.active_streams = {}
+        self.processing_history = []
+        
+    def start_stream(self, stream_id, config):
+        """بدء بث مباشر جديد"""
+        self.active_streams[stream_id] = {
+            "config": config,
+            "start_time": datetime.now(),
+            "status": "active",
+            "processing_nodes": [],
+            "viewers": 0
+        }
+        logging.info(f"🔴 بدء البث: {stream_id}")
+        
+    def distribute_processing(self, stream_id, task_type, data):
+        """توزيع معالجة البث على العقد المختلفة"""
+        if stream_id not in self.active_streams:
+            return {"error": "البث غير موجود"}
+            
+        # اختيار العقدة المناسبة
+        best_node = self._select_processing_node(task_type)
+        
+        # تنفيذ المعالجة
+        if best_node:
+            result = execute_remotely(task_type, [data], {})
+            self.active_streams[stream_id]["processing_nodes"].append(best_node)
+            return result
+        else:
+            # معالجة محلية
+            return self._process_locally(task_type, data)
+            
+    def _select_processing_node(self, task_type):
+        """اختيار أفضل عقدة للمعالجة"""
+        # منطق اختيار العقدة (مبسط)
+        return f"node_gpu_{np.random.randint(1, 4)}"
+        
+    def _process_locally(self, task_type, data):
+        """معالجة محلية احتياطية"""
+        return {"status": "processed_locally", "task": task_type}
+
+# دالة اختبار شاملة للبث المباشر
+def run_live_streaming_benchmark():
+    """اختبار شامل لنظام البث المباشر"""
+    print("\n📺🎮 اختبار نظام البث المباشر للألعاب والفيديو")
+    print("=" * 70)
+    
+    # بيانات تجريبية
+    game_stream_data = [f"frame_{i}" for i in range(60)]  # 60 إطار
+    game_events = ["goal", "save", "foul", "corner", "yellow_card"]
+    
+    multi_streams = [
+        {"quality": "1080p", "fps": 60, "complexity": 3},
+        {"quality": "720p", "fps": 30, "complexity": 2},
+        {"quality": "1440p", "fps": 45, "complexity": 4}
+    ]
+    
+    tests = [
+        ("معالجة بث لعبة", lambda: process_game_stream(game_stream_data, 60, "1920x1080", ["noise_reduction", "color_enhancement", "sharpening"])),
+        ("تحسين فيديو مباشر", lambda: real_time_video_enhancement(["upscaling", "noise_reduction", "hdr_enhancement"], "1080p", 60)),
+        ("معالجة متعددة البثوث", lambda: multi_stream_processing(multi_streams, "parallel")),
+        ("توليد تعليق ذكي", lambda: ai_commentary_generation(game_events, 50, "ar")),
+        ("تحسين جودة البث", lambda: stream_quality_optimization({"quality": "1080p"}, 5.0, 500))
+    ]
+    
+    coordinator = LiveStreamCoordinator()
+    
+    for test_name, test_func in tests:
+        print(f"\n🔄 تشغيل: {test_name}")
+        try:
+            result = test_func()
+            print(f"✅ نجح: {test_name}")
+            if "processing_time" in result:
+                print(f"⏱️ وقت المعالجة: {result['processing_time']:.2f}s")
+            if "quality_score" in result:
+                print(f"⭐ جودة: {result['quality_score']}%")
+        except Exception as e:
+            print(f"❌ فشل: {test_name} - {str(e)}")
+    
+    print("\n🏁 انتهى اختبار البث المباشر")
+
+if __name__ == "__main__":
+    run_live_streaming_benchmark()

load_balancer.py

@@ -0,0 +1,77 @@
+# load_balancer.py
+import peer_discovery, requests, time, smart_tasks, psutil, socket
+
+def send(peer, func, *args, **kw):
+    try:
+        r = requests.post(peer, json={"func": func,
+                                      "args": list(args),
+                                      "kwargs": kw}, timeout=12)
+        return r.json()
+    except Exception as e:
+        return {"error": str(e)}
+
+def choose_peer():
+    """اختيار أفضل جهاز - أولوية LAN ثم WAN"""
+    import socket
+    
+    lan_peers = []
+    wan_peers = []
+    
+    # تصنيف الأجهزة
+    for p in list(peer_discovery.PEERS):
+        ip = p.split('//')[1].split(':')[0] if '//' in p else p.split(':')[0]
+        if is_local_ip(ip):
+            lan_peers.append(p)
+        else:
+            wan_peers.append(p)
+    
+    # أولاً: جرب الأجهزة المحلية (LAN)
+    best_lan = find_best_peer(lan_peers)
+    if best_lan:
+        return best_lan
+    
+    # ثانياً: إذا لم تتوفر أجهزة محلية، جرب WAN
+    if internet_available():
+        best_wan = find_best_peer(wan_peers)
+        return best_wan
+    
+    return None
+
+def find_best_peer(peers):
+    """العثور على أفضل جهاز من قائمة معينة"""
+    best = None
+    for p in peers:
+        try:
+            cpu = requests.get(p.replace("/run", "/cpu"), timeout=2).json()["usage"]
+            best = (p, cpu) if best is None or cpu < best[1] else best
+        except: 
+            continue
+    return best[0] if best else None
+
+def is_local_ip(ip):
+    """فحص إذا كان IP محلي"""
+    return (
+        ip.startswith('192.168.') or 
+        ip.startswith('10.') or 
+        ip.startswith('172.') or
+        ip == '127.0.0.1'
+    )
+
+def internet_available():
+    """فحص توفر الإنترنت"""
+    try:
+        socket.create_connection(("8.8.8.8", 53), timeout=3)
+        return True
+    except:
+        return False
+
+while True:
+    peer = choose_peer()
+    if peer:
+        print(f"\n🛰️  إرسال إلى {peer}")
+        res = send(peer, "prime_calculation", 30000)
+    else:
+        print("\n⚙️  لا أقران؛ العمل محليّ على", socket.gethostname())
+        res = smart_tasks.prime_calculation(30000)
+    print("🔹 النتيجة (جزئية):", str(res)[:120])
+    time.sleep(10)

main.py

@@ -0,0 +1,260 @@
+#!/usr/bin/env python3
+"""
+main.py — نقطة تشغيل نظام OffloadHelper في ملف واحد
+خيارات سطر الأوامر:
+  -s / --stats-interval  ثواني بين كل طباعة لإحصائية الأقران (0 = مرة واحدة فقط)
+  --no-cli               تشغيل بلا قائمة تفاعلية حتى مع وجود TTY
+"""
+import os
+import sys
+import time
+import threading
+import subprocess
+import logging
+import argparse
+from pathlib import Path
+from typing import Any
+
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+
+# ───────────────────── ضبط المسارات ──────────────────────
+FILE = Path(__file__).resolve()
+BASE_DIR = FILE.parent
+PROJECT_ROOT = BASE_DIR.parent
+for p in (BASE_DIR, PROJECT_ROOT):
+    sys.path.insert(0, str(p))
+
+# ───────────────────── إعداد السجلات ─────────────────────
+os.makedirs("logs", exist_ok=True)
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+    handlers=[
+        logging.StreamHandler(),
+        logging.FileHandler("logs/main.log", mode="a")
+    ]
+)
+
+# ─────────────── تحميل متغيرات البيئة (اختياري) ───────────────
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+    logging.info("🔧 تم تحميل متغيرات البيئة من ‎.env")
+except ImportError:
+    logging.warning("🔧 python-dotenv غير مثبَّت؛ تَخطّي .env")
+
+# ─────────────── وحدات المشروع الداخلية ────────────────
+try:
+    from peer_discovery import (
+        register_service_lan,
+        discover_lan_loop,
+        register_with_central,
+        fetch_central_loop,
+        PEERS
+    )
+    from your_tasks import matrix_multiply, prime_calculation, data_processing
+    from distributed_executor import DistributedExecutor
+    from peer_statistics import print_peer_statistics
+except ImportError as e:
+    logging.error(f"❌ تعذّر استيراد وحدة: {e}")
+    sys.exit(1)
+
+# ─────────────── ثابتات التهيئة ───────────────
+CPU_PORT = int(os.getenv("CPU_PORT", "7520"))
+SHARED_SECRET = os.getenv("SHARED_SECRET", "my_shared_secret_123")
+PYTHON_EXE = sys.executable
+
+# ─────────────── خيارات سطر الأوامر ───────────────
+parser = argparse.ArgumentParser()
+parser.add_argument(
+    "--stats-interval", "-s",
+    type=int,
+    default=0,
+    help="ثواني بين كل طباعة لإحصائية الأقران (0 = مرة واحدة فقط)"
+)
+parser.add_argument(
+    "--no-cli",
+    action="store_true",
+    help="تعطيل القائمة التفاعلية حتى عند وجود TTY"
+)
+args = parser.parse_args()
+
+# ─────────────── خادم Flask البسيط ───────────────
+flask_app = Flask(__name__)
+CORS(flask_app, resources={r"/*": {"origins": "*"}})
+
+@flask_app.route("/run_task", methods=["POST"])
+def run_task():
+    try:
+        # قراءة البيانات
+        data = request.get_json() if request.is_json else request.form
+        task_id = data.get("task_id")
+        
+        if not task_id:
+            return jsonify(error="يجب تحديد task_id"), 400
+
+        # معالجة المهام
+        if task_id == "1":
+            result = matrix_multiply(500)
+        elif task_id == "2":
+            result = prime_calculation(100_000)
+        elif task_id == "3":
+            result = data_processing(10_000)
+        else:
+            return jsonify(error="معرف المهمة غير صحيح"), 400
+
+        return jsonify(result=result)
+
+    except Exception as e:
+        logging.error(f"خطأ في معالجة المهمة: {str(e)}", exc_info=True)
+        return jsonify(error="حدث خطأ داخلي في الخادم"), 500
+def start_flask_server():
+    ip_public = os.getenv("PUBLIC_IP", "127.0.0.1")
+    logging.info(f"🌐 Flask متوفر على: http://{ip_public}:{CPU_PORT}/run_task")
+    flask_app.run(host="0.0.0.0", port=CPU_PORT, debug=False)
+
+# ─────────────── خدمات خلفية محلية ───────────────
+def start_services():
+    """peer_server و load_balancer"""
+    try:
+        subprocess.Popen([PYTHON_EXE, "peer_server.py", "--port", str(CPU_PORT)])
+        subprocess.Popen([PYTHON_EXE, "load_balancer.py"])
+        logging.info("✅ تم تشغيل الخدمات الخلفيّة")
+    except Exception as exc:
+        logging.error(f"❌ خطأ بتشغيل الخدمات الخلفية: {exc}")
+
+# ───��─────────── مهام مثالية محلية ───────────────
+def example_task(x: int) -> int:
+    return x * x
+
+def benchmark(fn, *args):
+    t0 = time.time()
+    res = fn(*args)
+    return time.time() - t0, res
+
+# ─────────────── طباعة الإحصائية دوريًّا ─────────────
+def stats_loop(interval: int, executor: DistributedExecutor):
+    while True:
+        peers_now = [
+            {"ip": host, "port": port}
+            for (host, port) in executor.peer_registry.get_all()
+        ]
+        print_peer_statistics(peers_now)
+        time.sleep(interval)
+
+# ─────────────── القائمة التفاعلية CLI ─────────────
+def menu(executor: DistributedExecutor):
+    tasks = {
+        "1": ("ضرب المصفوفات", matrix_multiply, 500),
+        "2": ("حساب الأعداد الأولية", prime_calculation, 100_000),
+        "3": ("معالجة البيانات", data_processing, 10_000),
+        "5": ("مهمة موزعة (مثال)", example_task, 42),
+    }
+
+    while True:
+        print("\n🚀 نظام توزيع المهام الذكي")
+        for k, (title, _, _) in tasks.items():
+            print(f"{k}: {title}")
+        print("q: خروج")
+        choice = input("اختر المهمة: ").strip().lower()
+
+        if choice == "q":
+            print("🛑 تم إنهاء البرنامج.")
+            break
+        if choice not in tasks:
+            print("⚠️ اختيار غير صحيح.")
+            continue
+
+        name, fn, arg = tasks[choice]
+        print(f"\nتشغيل: {name}…")
+
+        try:
+            if choice == "5":
+                logging.info("📡 إرسال المهمة إلى العقد الموزَّعة…")
+                future = executor.submit(fn, arg)
+                print(f"✅ النتيجة (موزعة): {future.result()}")
+            else:
+                dur, res = benchmark(fn, arg)
+                print(f"✅ النتيجة: {res}\n⏱️ الوقت: {dur:.3f} ث")
+        except Exception as exc:
+            print(f"❌ خطأ في تنفيذ المهمة: {exc}")
+
+# ─────────────── الدالة الرئيسية ───────────────
+def main():
+    # 1) خدمات back‑end
+    start_services()
+
+    # 2) مهيّئ الموزِّع
+    executor = DistributedExecutor(SHARED_SECRET)
+    executor.peer_registry.register_service("node_main", CPU_PORT)
+
+    # 3) إضافة الأقران المكتشفين
+    for peer_url in list(PEERS):
+        try:
+            host, port_str = peer_url.split("//")[1].split("/run")[0].split(":")
+            executor.peer_registry.register_service(
+                f"peer_{host.replace('.', '_')}",
+                int(port_str)
+            )
+        except Exception as exc:
+            logging.warning(f"⚠️ تخطّي peer ({peer_url}): {exc}")
+
+    # 4) طباعة أولية
+    initial_peers = [
+        {"ip": host, "port": int(port)}
+        for peer_url in PEERS
+        if (hp := peer_url.split("//")[1].split("/run")[0]).count(":") == 1
+        for host, port in [hp.split(":")]
+    ]
+    print_peer_statistics(initial_peers)
+
+    # 5) حلقة إحصائية دورية
+    if args.stats_interval > 0:
+        threading.Thread(
+            target=stats_loop,
+            args=(args.stats_interval, executor),
+            daemon=True
+        ).start()
+
+    logging.info("✅ النظام جاهز للعمل")
+
+    # 6) CLI إن توفر TTY ولم يُطلَب no-cli
+    if not args.no_cli and sys.stdin.isatty():
+        menu(executor)
+    else:
+        logging.info("ℹ️ القائمة التفاعلية معطّلة (no TTY أو --no-cli)")
+
+# ─────────────── تشغيل البرنامج ───────────────
+if __name__ == "__main__":
+    # Zeroconf
+    threading.Thread(target=register_service_lan, daemon=True).start()
+    threading.Thread(target=discover_lan_loop, daemon=True).start()
+
+    # خادم وسيط مركزي
+    register_with_central()
+    threading.Thread(target=fetch_central_loop, daemon=True).start()
+
+    # ماسح إنترنت (اختياري)
+    try:
+        from internet_scanner import internet_scanner
+        threading.Thread(
+            target=internet_scanner.start_continuous_scan,
+            daemon=True
+        ).start()
+        logging.info("🔍 بدء المسح المستمر للإنترنت")
+    except ImportError:
+        logging.warning("🔍 internet_scanner غير متوافر – تم التخطي")
+
+    # Flask
+    threading.Thread(target=start_flask_server, daemon=True).start()
+
+    # وحدة تحكم (اختياري)
+    try:
+        from your_control import control
+        control.start()
+    except ImportError:
+        logging.info("🛈 your_control غير متوفّر �� تشغيل افتراضي")
+
+    # CLI / إحصائية
+    main()

main.spec

@@ -0,0 +1,38 @@
+# -*- mode: python ; coding: utf-8 -*-
+
+
+a = Analysis(
+    ['main.py'],
+    pathex=[],
+    binaries=[],
+    datas=[],
+    hiddenimports=[],
+    hookspath=[],
+    hooksconfig={},
+    runtime_hooks=[],
+    excludes=[],
+    noarchive=False,
+    optimize=0,
+)
+pyz = PYZ(a.pure)
+
+exe = EXE(
+    pyz,
+    a.scripts,
+    a.binaries,
+    a.datas,
+    [],
+    name='main',
+    debug=False,
+    bootloader_ignore_signals=False,
+    strip=False,
+    upx=True,
+    upx_exclude=[],
+    runtime_tmpdir=None,
+    console=False,
+    disable_windowed_traceback=False,
+    argv_emulation=False,
+    target_arch=None,
+    codesign_identity=None,
+    entitlements_file=None,
+)

offload_lib.py

@@ -0,0 +1,203 @@
+#!/usr/bin/env python3
+# offload_lib.py
+
+import time
+import math
+import random
+import psutil
+import requests
+import socket
+from functools import wraps
+from zeroconf import Zeroconf, ServiceBrowser
+import logging
+
+# إعداد السجل
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+
+# إعدادات التحميل
+MAX_CPU = 0.6  # عتبة استخدام CPU فقط
+
+class PeerListener:
+    def __init__(self):
+        self.peers = []
+
+    def add_service(self, zc, type, name):
+        info = zc.get_service_info(type, name)
+        if info:
+            ip = socket.inet_ntoa(info.addresses[0])
+            self.peers.append(f"{ip}:{info.port}")
+            logging.info(f"🔗 جهاز مكتشف: {ip}:{info.port}")
+
+    def update_service(self, zc, type, name):
+        logging.debug(f"🔄 تم تحديث الخدمة: {name}")
+        pass  # هنا فقط لتفادي التحذير
+
+def discover_peers(timeout=1.5):
+    """اكتشاف الأجهزة المتاحة - أولوية LAN ثم WAN ثم الإنترنت مع فحص المشروع"""
+    import peer_discovery
+    from project_identifier import verify_project_compatibility
+
+    zc = Zeroconf()
+    listener = PeerListener()
+    ServiceBrowser(zc, "_http._tcp.local.", listener)
+    time.sleep(timeout)
+    zc.close()
+
+    lan_peers = []
+    wan_peers = []
+    internet_peers = []
+
+    for peer in listener.peers:
+        ip = peer.split(':')[0]
+        if verify_peer_project(ip):
+            if is_local_network(ip):
+                lan_peers.append(peer)
+            else:
+                wan_peers.append(peer)
+
+    all_discovered = list(peer_discovery.PEERS)
+    for peer_url in all_discovered:
+        peer_ip = peer_url.split("://")[1].split(":")[0]
+        if verify_peer_project(peer_ip):
+            if is_local_network(peer_ip):
+                if peer_url not in lan_peers:
+                    lan_peers.append(peer_url)
+            else:
+                if peer_url not in wan_peers:
+                    internet_peers.append(peer_url)
+
+    all_peers = lan_peers + wan_peers + internet_peers
+    logging.info(f"اكتُشف {len(all_peers)} جهاز DTS متوافق - LAN: {len(lan_peers)}, WAN: {len(wan_peers)}, Internet: {len(internet_peers)}")
+
+    return all_peers
+
+def verify_peer_project(ip, port=7520):
+    """فحص إذا كان الجهاز يحتوي على نفس المشروع"""
+    try:
+        from project_identifier import verify_project_compatibility
+
+        project_url = f"http://{ip}:{port}/project_info"
+        response = requests.get(project_url, timeout=2)
+
+        if response.status_code == 200:
+            remote_info = response.json()
+            return verify_project_compatibility(remote_info)
+
+    except:
+        pass
+    return False
+
+def is_local_network(ip):
+    """فحص إذا كان IP في الشبكة المحلية"""
+    try:
+        import ipaddress
+        addr = ipaddress.ip_address(ip)
+        return (
+            addr.is_private or
+            str(addr).startswith('192.168.') or
+            str(addr).startswith('10.') or
+            str(addr).startswith('172.')
+        )
+    except:
+        return False
+
+def try_offload(peer, payload, max_retries=3):
+    """محاولة إرسال المهمة إلى جهاز آخر"""
+    url = f"http://{peer}/run"
+    for attempt in range(max_retries):
+        try:
+            response = requests.post(url, json=payload, timeout=10)
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            logging.warning(f"فشل المحاولة {attempt + 1} لـ {peer}: {str(e)}")
+            time.sleep(0.5 * (attempt + 1))
+    raise ConnectionError(f"فشل جميع المحاولات لـ {peer}")
+
+def estimate_complexity(func, args, kwargs):
+    """تقدير تعقيد المهمة"""
+    if func.__name__ == "matrix_multiply":
+        return args[0] ** 2
+    elif func.__name__ == "prime_calculation":
+        return args[0] / 100
+    elif func.__name__ == "data_processing":
+        return args[0] / 10
+    elif func.__name__ == "image_processing_emulation":
+        return args[0] * 5
+    return 1  # قيمة افتراضية
+
+def offload(func):
+    """ديكوراتور لتوزيع المهام"""
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        cpu = psutil.cpu_percent(interval=0.5) / 100.0
+        mem = psutil.virtual_memory().available / (1024**2)
+        complexity = estimate_complexity(func, args, kwargs)
+
+        logging.info(f"حمل النظام - CPU: {cpu:.2f}, الذاكرة: {mem:.1f}MB, تعقيد المهمة: {complexity}")
+
+        if complexity > 50 or cpu > MAX_CPU:
+            try:
+                peers = discover_peers()
+                if peers:
+                    payload = {
+                        "func": func.__name__,
+                        "args": args,
+                        "kwargs": kwargs,
+                        "complexity": complexity
+                    }
+                    selected_peer = random.choice(peers)
+                    logging.info(f"إرسال المهمة إلى {selected_peer}")
+                    return try_offload(selected_peer, payload)
+            except Exception as e:
+                logging.error(f"خطأ في التوزيع: {str(e)}")
+
+        logging.info("تنفيذ المهمة محلياً")
+        return func(*args, **kwargs)
+    return wrapper
+
+# المهام القابلة للتوزيع:
+
+@offload
+def matrix_multiply(size):
+    """ضرب مصفوفتين عشوائيتين بالحجم"""
+    import numpy as np
+    A = np.random.rand(size, size)
+    B = np.random.rand(size, size)
+    return np.dot(A, B).tolist()
+
+@offload
+def prime_calculation(n):
+    """حساب الأعداد الأولية"""
+    primes = []
+    for num in range(2, n + 1):
+        is_prime = True
+        for i in range(2, int(math.sqrt(num)) + 1):
+            if num % i == 0:
+                is_prime = False
+                break
+        if is_prime:
+            primes.append(num)
+    return {"primes_count": len(primes), "primes": primes}
+
+@offload
+def data_processing(data_size):
+    """معالجة بيانات كبيرة"""
+    processed_data = []
+    for i in range(data_size):
+        result = sum(math.sin(x) * math.cos(x) for x in range(i, i + 100))
+        processed_data.append(result)
+    return {"processed_items": len(processed_data)}
+
+@offload
+def image_processing_emulation(iterations):
+    """محاكاة معالجة الصور"""
+    results = []
+    for i in range(iterations):
+        fake_processing = sum(math.sqrt(x) for x in range(i * 100, (i + 1) * 100))
+        results.append(fake_processing)
+        time.sleep(0.01)
+    return {"iterations": iterations, "results": results}

package.json

@@ -0,0 +1,109 @@
+{
+  "name": "rest-express",
+  "version": "1.0.0",
+  "type": "module",
+  "license": "MIT",
+  "scripts": {
+    "dev": "NODE_ENV=development tsx server/index.ts",
+    "build": "vite build && esbuild server/index.ts --platform=node --packages=external --bundle --format=esm --outdir=dist",
+    "start": "NODE_ENV=production node dist/index.js",
+    "check": "tsc",
+    "db:push": "drizzle-kit push"
+  },
+  "dependencies": {
+    "@hookform/resolvers": "^3.10.0",
+    "@jridgewell/trace-mapping": "^0.3.25",
+    "@neondatabase/serverless": "^0.10.4",
+    "@radix-ui/react-accordion": "^1.2.4",
+    "@radix-ui/react-alert-dialog": "^1.1.7",
+    "@radix-ui/react-aspect-ratio": "^1.1.3",
+    "@radix-ui/react-avatar": "^1.1.4",
+    "@radix-ui/react-checkbox": "^1.1.5",
+    "@radix-ui/react-collapsible": "^1.1.4",
+    "@radix-ui/react-context-menu": "^2.2.7",
+    "@radix-ui/react-dialog": "^1.1.7",
+    "@radix-ui/react-dropdown-menu": "^2.1.7",
+    "@radix-ui/react-hover-card": "^1.1.7",
+    "@radix-ui/react-label": "^2.1.3",
+    "@radix-ui/react-menubar": "^1.1.7",
+    "@radix-ui/react-navigation-menu": "^1.2.6",
+    "@radix-ui/react-popover": "^1.1.7",
+    "@radix-ui/react-progress": "^1.1.3",
+    "@radix-ui/react-radio-group": "^1.2.4",
+    "@radix-ui/react-scroll-area": "^1.2.4",
+    "@radix-ui/react-select": "^2.1.7",
+    "@radix-ui/react-separator": "^1.1.3",
+    "@radix-ui/react-slider": "^1.2.4",
+    "@radix-ui/react-slot": "^1.2.0",
+    "@radix-ui/react-switch": "^1.1.4",
+    "@radix-ui/react-tabs": "^1.1.4",
+    "@radix-ui/react-toast": "^1.2.7",
+    "@radix-ui/react-toggle": "^1.1.3",
+    "@radix-ui/react-toggle-group": "^1.1.3",
+    "@radix-ui/react-tooltip": "^1.2.0",
+    "@tanstack/react-query": "^5.60.5",
+    "bonjour-service": "^1.3.0",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "cmdk": "^1.1.1",
+    "connect-pg-simple": "^10.0.0",
+    "date-fns": "^3.6.0",
+    "drizzle-orm": "^0.39.1",
+    "drizzle-zod": "^0.7.0",
+    "embla-carousel-react": "^8.6.0",
+    "express": "^4.21.2",
+    "express-session": "^1.18.1",
+    "framer-motion": "^11.13.1",
+    "input-otp": "^1.4.2",
+    "lucide-react": "^0.453.0",
+    "memorystore": "^1.6.7",
+    "nanoid": "^5.1.5",
+    "next-themes": "^0.4.6",
+    "passport": "^0.7.0",
+    "passport-local": "^1.0.0",
+    "react": "^18.3.1",
+    "react-day-picker": "^8.10.1",
+    "react-dom": "^18.3.1",
+    "react-hook-form": "^7.55.0",
+    "react-icons": "^5.4.0",
+    "react-resizable-panels": "^2.1.7",
+    "recharts": "^2.15.2",
+    "tailwind-merge": "^2.6.0",
+    "tailwindcss-animate": "^1.0.7",
+    "tw-animate-css": "^1.2.5",
+    "vaul": "^1.1.2",
+    "wouter": "^3.3.5",
+    "ws": "^8.18.0",
+    "zod": "^3.24.2",
+    "zod-validation-error": "^3.4.0"
+  },
+  "devDependencies": {
+    "@replit/vite-plugin-cartographer": "^0.2.7",
+    "@replit/vite-plugin-runtime-error-modal": "^0.0.3",
+    "@tailwindcss/typography": "^0.5.15",
+    "@tailwindcss/vite": "^4.1.3",
+    "@types/connect-pg-simple": "^7.0.3",
+    "@types/express": "4.17.21",
+    "@types/express-session": "^1.18.0",
+    "@types/node": "20.16.11",
+    "@types/passport": "^1.0.16",
+    "@types/passport-local": "^1.0.38",
+    "@types/react": "^18.3.11",
+    "@types/react-dom": "^18.3.1",
+    "@types/ws": "^8.5.13",
+    "@vitejs/plugin-react": "^4.3.2",
+    "autoprefixer": "^10.4.20",
+    "drizzle-kit": "^0.30.4",
+    "electron": "^37.1.0",
+    "electron-builder": "^26.0.12",
+    "esbuild": "^0.25.0",
+    "postcss": "^8.4.47",
+    "tailwindcss": "^3.4.17",
+    "tsx": "^4.19.1",
+    "typescript": "5.6.3",
+    "vite": "^5.4.19"
+  },
+  "optionalDependencies": {
+    "bufferutil": "^4.0.8"
+  }
+}

peer_discovery.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+import os
+import socket
+import threading
+import time
+import logging
+
+import requests
+from zeroconf import Zeroconf, ServiceInfo, ServiceBrowser
+
+# 👇 إعداد الـ peer discovery عبر LAN وInternet
+SERVICE = "_tasknode._tcp.local."
+PORT = int(os.getenv("CPU_PORT", "7520"))
+PEERS = set()  # مجموعة URLs للأقران (/run)
+
+# 🌐 خادم وسيط مركزي (Central Registry)
+CENTRAL_REGISTRY_URL = "https://cv4790811.regru.cloud"
+
+# 🟢 دالة لحساب IP العام أو المحلي
+# تستخدم HTTP API للحصول على IP عام ثم fallback إلى LAN
+
+def get_local_ip():
+    # حاول الحصول على IP عام
+    try:
+        r = requests.get("https://api.ipify.org?format=json", timeout=3)
+        r.raise_for_status()
+        data = r.json()
+        return data.get("ip", "127.0.0.1")
+    except Exception:
+        # fallback إلى LAN IP
+        try:
+            s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            s.connect(("8.8.8.8", 80))
+            return s.getsockname()[0]
+        except Exception:
+            return "127.0.0.1"
+        finally:
+            try:
+                s.close()
+            except Exception:
+                pass
+
+# ❶ تسجيل الخدمة في شبكة LAN عبر Zeroconf
+# للحفاظ على قدرة اكتشاف peers في نفس الشبكة المحلية
+def register_service_lan():
+    zc = Zeroconf()
+    local_ip = get_local_ip()
+    info = ServiceInfo(
+        SERVICE,
+        f"{socket.gethostname()}.{SERVICE}",
+        addresses=[socket.inet_aton(local_ip)],
+        port=PORT,
+        properties={b'load': b'0'}
+    )
+    try:
+        zc.register_service(info)
+        print(f"✅ LAN service registered: {local_ip}:{PORT}")
+    except Exception as e:
+        print(f"❌ LAN registration failed: {e}")
+
+# ❷ مستمع لاكتشاف أجهزة LAN عبر Zeroconf
+class Listener:
+    def add_service(self, zc, t, name):
+        info = zc.get_service_info(t, name)
+        if info and info.addresses:
+            ip = socket.inet_ntoa(info.addresses[0])
+            peer_url = f"http://{ip}:{info.port}/run"
+            if peer_url not in PEERS:
+                PEERS.add(peer_url)
+                print(f"🔗 LAN peer discovered: {peer_url}")
+    def update_service(self, zc, t, name):
+        self.add_service(zc, t, name)
+    def remove_service(self, zc, t, name):
+        print(f"❌ LAN peer removed: {name}")
+
+# حلقة اكتشاف LAN مستمرة
+def discover_lan_loop():
+    zc = Zeroconf()
+    ServiceBrowser(zc, SERVICE, Listener())
+    print(f"🔍 Started LAN discovery for {SERVICE}")
+    while True:
+        time.sleep(5)
+
+# ❸ تسجيل العقدة في الخادم المركزي
+# ترسل بياناتها إلى /register وتضيف باقي الأقران
+def register_with_central():
+    node_id = os.getenv("NODE_ID", socket.gethostname())
+    info = {"node_id": node_id, "ip": get_local_ip(), "port": PORT}
+    try:
+        resp = requests.post(f"{CENTRAL_REGISTRY_URL}/register", json=info, timeout=5)
+        resp.raise_for_status()
+        peers_list = resp.json()
+        for p in peers_list:
+            peer_url = f"http://{p['ip']}:{p['port']}/run"
+            if peer_url not in PEERS:
+                PEERS.add(peer_url)
+                print(f"🌐 Registered and discovered central peer: {peer_url}")
+    except Exception as e:
+        print(f"❌ Central registration failed: {e}")
+
+# ❹ مزامنة الأقران من الخادم المركزي بشكل دوري
+# تُحدّث مجموعة PEERS كل 5 دقائق عن طريق /peers endpoint
+def fetch_central_loop():
+    print("🔄 Central registry sync loop started")
+    while True:
+        try:
+            resp = requests.get(f"{CENTRAL_REGISTRY_URL}/peers", timeout=5)
+            resp.raise_for_status()
+            peers_list = resp.json()
+            for p in peers_list:
+                peer_url = f"http://{p['ip']}:{p['port']}/run"
+                if peer_url not in PEERS:
+                    PEERS.add(peer_url)
+                    print(f"🌐 Central peer discovered: {peer_url}")
+        except Exception as e:
+            print(f"⚠️ Fetch central peers failed: {e}")
+        time.sleep(300)
+
+# 🚀 دالة الإدخال الرئيسيّة
+def main():
+    logging.basicConfig(level=logging.INFO)
+    print("🚀 Peer Discovery System starting...")
+
+    # Zeroconf LAN registration & discovery
+    threading.Thread(target=register_service_lan, daemon=True).start()
+    threading.Thread(target=discover_lan_loop, daemon=True).start()
+
+    # التسجيل في الخادم الوسيط ومزامنة الأقران
+    register_with_central()
+    threading.Thread(target=fetch_central_loop, daemon=True).start()
+
+    # إبقاء السكربت قيد التشغيل
+    try:
+        while True:
+            time.sleep(60)
+    except KeyboardInterrupt:
+        print("🛑 Exiting...")
+
+if __name__ == "__main__":
+    main()

peer_registry.py

@@ -0,0 +1,67 @@
+import socket
+import time
+from zeroconf import Zeroconf, ServiceBrowser, ServiceInfo
+
+class Listener:
+    def __init__(self):
+        self.peers = []
+
+    def add_service(self, zc, type_, name):
+        info = zc.get_service_info(type_, name)
+        if info:
+            ip = socket.inet_ntoa(info.addresses[0])
+            peer_data = {
+                'ip': ip,
+                'port': info.port,
+                'load': float(info.properties.get(b'load', 0)),
+                'node_id': info.properties.get(b'node_id', b'unknown').decode(),
+                'last_seen': time.time()
+            }
+            if peer_data not in self.peers:
+                self.peers.append(peer_data)
+
+    def update_service(self, zc, type_, name):
+        """مطلوب بواسطة Zeroconf"""
+        self.add_service(zc, type_, name)
+
+    def remove_service(self, zc, type_, name):
+        """اختياري"""
+        pass
+
+def register_service(ip: str, port: int, load: float = 0.0):
+    zc = Zeroconf()
+    service_name = f"{socket.gethostname()}-{int(time.time())}._tasknode._tcp.local."
+    service_info = ServiceInfo(
+        "_tasknode._tcp.local.",
+        service_name,
+        addresses=[socket.inet_aton(ip)],
+        port=port,
+        properties={
+            b'load': str(load).encode(),
+            b'node_id': socket.gethostname().encode()
+        }
+    )
+    zc.register_service(service_info)
+    print(f"✅ Service registered: {service_name} @ {ip}:{port}")
+    return zc  # أبقِ المرجع حياً
+
+def discover_peers(timeout=2):
+    zc = Zeroconf()
+    listener = Listener()
+    ServiceBrowser(zc, "_tasknode._tcp.local.", listener)
+    time.sleep(timeout)
+    zc.close()
+    return listener.peers
+
+if __name__ == "__main__":
+    local_ip = socket.gethostbyname(socket.gethostname())
+    port = 7520
+
+    zc = register_service(local_ip, port, load=0.1)
+
+    peers = discover_peers()
+    print("✅ Available peers:", peers)
+
+    input("🔵 Press Enter to exit...\n")
+    zc.close()
+

peer_server.py

@@ -0,0 +1,37 @@
+# peer_server.py
+
+from flask import Flask, request, jsonify  # استيراد request و jsonify مع Flask
+import psutil
+import smart_tasks
+import time
+import socket
+import peer_discovery  # إذا كان يستخدم لاحقًا
+
+app = Flask(__name__)  # إنشاء التطبيق
+
+@app.route("/cpu")
+def cpu():
+    # يعيد نسبة استخدام المعالج
+    return jsonify(usage=psutil.cpu_percent(interval=0.3))
+
+@app.route("/run", methods=["POST"])
+def run():
+    data = request.get_json(force=True)
+    fn_name = data.get("func")
+    fn = getattr(smart_tasks, fn_name, None)
+    if not fn:
+        return jsonify(error="function-not-found"), 404
+    try:
+        start = time.time()
+        result = fn(*data.get("args", []), **data.get("kwargs", {}))
+        return jsonify(
+            result=result,
+            host=socket.gethostname(),
+            took=round(time.time() - start, 3)
+        )
+    except Exception as e:
+        return jsonify(error=str(e)), 500
+
+if __name__ == "__main__":  # التصحيح هنا
+    app.run(host="0.0.0.0", port=7520)
+

peer_statistics.py

@@ -0,0 +1,21 @@
+from collections import Counter
+import ipaddress
+
+def print_peer_statistics(discovered_peers):
+    ips = [peer['ip'] for peer in discovered_peers]
+    ip_counts = Counter(ips)
+
+    def classify_ip(ip):
+        try:
+            ip_obj = ipaddress.ip_address(ip)
+            if ip_obj.is_private:
+                return 'داخلي'
+            else:
+                return 'خارجي'
+        except ValueError:
+            return 'محلي'
+
+    print("\n📊 إحصائية عدد الأجهزة حسب النوع:\n")
+    for ip, count in ip_counts.items():
+        category = classify_ip(ip)
+        print(f"• {ip} ({category}): {count} جهاز")

postcss.config.js

@@ -0,0 +1,6 @@
+export default {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+}

processor_manager.py

@@ -0,0 +1,73 @@
+# processor_manager.py
+
+import psutil
+from collections import deque
+import logging
+
+logging.basicConfig(level=logging.INFO)
+
+class ResourceMonitor:
+    def __init__(self):
+        self.cpu_history = deque(maxlen=10)
+        self.mem_history = deque(maxlen=10)
+        # حد استقبال المهمات الآن 40% CPU بدل 30%
+        self.receive_cpu_threshold = 0.40  
+
+    def current_load(self):
+        cpu = psutil.cpu_percent(interval=0.5) / 100.0    # كنسبة (0.0 - 1.0)
+        mem = psutil.virtual_memory().available / (1024**2)  # متاح بالـ MB
+
+        self.cpu_history.append(cpu)
+        self.mem_history.append(mem)
+
+        avg_cpu = sum(self.cpu_history) / len(self.cpu_history)
+        avg_mem = sum(self.mem_history) / len(self.mem_history)
+
+        logging.info(f"Instant CPU: {cpu:.2%}, Instant MEM: {mem:.1f}MB")
+        logging.info(f"Avg CPU: {avg_cpu:.2%}, Avg MEM: {avg_mem:.1f}MB")
+
+        recommendation = "offload" if (avg_cpu > 0.5 or avg_mem < 2048) else "local"
+        can_receive = avg_cpu <= self.receive_cpu_threshold
+
+        return {
+            "instant": {"cpu": cpu, "mem": mem},
+            "average": {"cpu": avg_cpu, "mem": avg_mem},
+            "recommendation": recommendation,
+            "can_receive": can_receive
+        }
+
+def trigger_offload():
+    """عملية توزيع المهام التجريبية"""
+    print("⚠️ تم استدعاء توزيع المهام (اختباري)")
+
+def should_offload(task_complexity=0):
+    monitor = ResourceMonitor()
+    status = monitor.current_load()
+
+    avg_cpu = status['average']['cpu']
+    avg_mem = status['average']['mem']
+
+    if avg_cpu > 0.6 or avg_mem < 2048 or task_complexity > 75:
+        trigger_offload()
+        return True
+
+    return False
+
+def can_receive_task():
+    """
+    يعيد True إذا كان بالإمكان استقبال مهمة جديدة،
+    أي عندما يكون متوسط استهلاك الـ CPU ≤ 40%.
+    """
+    return ResourceMonitor().current_load()["can_receive"]
+
+if __name__ == "__main__":
+    status = ResourceMonitor().current_load()
+    if not status["can_receive"]:
+        print(f"🚫 لا يمكن استقبال مهام جديدة (Avg CPU: {status['average']['cpu']:.0%})")
+    else:
+        print(f"✅ يمكن استقبال مهام جديدة (Avg CPU: {status['average']['cpu']:.0%})")
+
+    if should_offload(80):
+        print("💡 ينصح بتوزيع المهمة")
+    else:
+        print("✅ يمكن تنفيذ المهمة محلياً")

project_identifier.py

@@ -0,0 +1,41 @@
+
+"""
+project_identifier.py - معرف المشروع للتحقق من الهوية
+"""
+import json
+from flask import jsonify
+
+PROJECT_INFO = {
+    "project_name": "distributed-task-system",
+    "version": "1.0",
+    "description": "نظام توزيع المهام الذكي",
+    "author": "DTS Team",
+    "features": [
+        "matrix_multiply",
+        "prime_calculation", 
+        "data_processing",
+        "video_processing",
+        "live_streaming",
+        "enhanced_ai"
+    ],
+    "signature": "DTS_2024_SMART_DISTRIBUTION"
+}
+
+def get_project_info():
+    """إرجاع معلومات المشروع"""
+    return PROJECT_INFO
+
+def verify_project_compatibility(remote_info):
+    """التحقق من توافق المشروع مع جهاز آخر"""
+    if not isinstance(remote_info, dict):
+        return False
+        
+    return (
+        remote_info.get("project_name") == PROJECT_INFO["project_name"] and
+        remote_info.get("version") == PROJECT_INFO["version"] and
+        remote_info.get("signature") == PROJECT_INFO["signature"]
+    )
+
+def create_project_endpoint():
+    """إنشاء endpoint لمعلومات المشروع"""
+    return jsonify(PROJECT_INFO)

quick_connection_test.py

@@ -0,0 +1,49 @@
+
+#!/usr/bin/env python3
+# اختبار سريع للتحقق من حالة النظام
+
+import requests
+import time
+import json
+from offload_lib import discover_peers, matrix_multiply
+
+def test_connection():
+    """اختبار سريع للاتصال"""
+    print("🚀 اختبار اتصال سريع...")
+    
+    # 1. فحص الخادم المحلي
+    try:
+        response = requests.get("http://localhost:7520/health", timeout=3)
+        if response.status_code == 200:
+            print("✅ الخادم المحلي يعمل")
+        else:
+            print("❌ مشكلة في الخادم المحلي")
+            return False
+    except:
+        print("❌ الخادم المحلي غير متاح")
+        return False
+    
+    # 2. اختبار اكتشاف الأجهزة
+    print("🔍 البحث عن الأجهزة...")
+    peers = discover_peers(timeout=2)
+    print(f"📱 تم اكتشاف {len(peers)} جهاز")
+    
+    # 3. اختبار مهمة بسيطة
+    print("⚙️ اختبار مهمة بسيطة...")
+    start_time = time.time()
+    try:
+        result = matrix_multiply(5)
+        duration = time.time() - start_time
+        print(f"✅ تمت المعالجة في {duration:.2f} ثانية")
+        print(f"📊 النتيجة: مصفوفة {len(result)}x{len(result[0])}")
+        return True
+    except Exception as e:
+        print(f"❌ فشل في المعالجة: {e}")
+        return False
+
+if __name__ == "__main__":
+    if test_connection():
+        print("\n🎉 النظام يعمل بشكل جيد!")
+        print("💡 يمكنك الآن تشغيل: python test_distributed_system.py")
+    else:
+        print("\n⚠️ هناك مشاكل تحتاج إصلاح")

quick_test.py

@@ -0,0 +1,80 @@
+
+#!/usr/bin/env python3
+# quick_test.py - اختبار سريع لنظام التوزيع
+
+import requests
+import time
+from offload_lib import discover_peers
+
+def quick_connectivity_test():
+    """اختبار سريع للاتصال والتوزيع"""
+    print("🚀 اختبار سريع لنظام التوزيع")
+    print("-" * 40)
+    
+    # 1. اكتشاف الأجهزة
+    print("🔍 البحث عن الأجهزة...")
+    peers = discover_peers(timeout=2)
+    
+    if not peers:
+        print("❌ لم يتم العثور على أجهزة أخرى")
+        return False
+    
+    print(f"✅ تم العثور على {len(peers)} جهاز:")
+    for peer in peers:
+        print(f"   📱 {peer}")
+    
+    # 2. اختبار الاتصال السريع
+    working_peers = []
+    for peer in peers:
+        try:
+            response = requests.get(f"{peer}/health", timeout=3)
+            if response.status_code == 200:
+                working_peers.append(peer)
+                print(f"✅ {peer} - متصل ويعمل")
+            else:
+                print(f"⚠️ {peer} - يستجيب لكن بخطأ")
+        except:
+            print(f"❌ {peer} - غير متصل")
+    
+    if not working_peers:
+        print("❌ لا توجد أجهزة تعمل بشكل صحيح")
+        return False
+    
+    # 3. اختبار إرسال مهمة بسيطة
+    print(f"\n📡 اختبار إرسال مهمة إلى {working_peers[0]}...")
+    
+    task = {
+        "func": "matrix_multiply",
+        "args": [5],
+        "kwargs": {}
+    }
+    
+    try:
+        start_time = time.time()
+        response = requests.post(f"{working_peers[0]}/run", json=task, timeout=10)
+        duration = time.time() - start_time
+        
+        if response.status_code == 200:
+            result = response.json()
+            print(f"✅ تمت المعالجة بنجاح في {duration:.2f} ثانية")
+            print(f"📊 النتيجة: تم ضرب مصفوفة 5x5")
+            return True
+        else:
+            print(f"❌ فشل في المعالجة - كود الخطأ: {response.status_code}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ خطأ في الإرسال: {str(e)}")
+        return False
+
+if __name__ == "__main__":
+    success = quick_connectivity_test()
+    
+    if success:
+        print("\n🎉 النظام يعمل بشكل صحيح!")
+        print("💡 يمكنك الآن تشغيل الاختبار الشامل: python test_distributed_system.py")
+    else:
+        print("\n⚠️ هناك مشاكل في النظام، تحقق من:")
+        print("   1. تشغيل الخادم على الأجهزة الأخرى")
+        print("   2. الاتصال بالشبكة")
+        print("   3. إعدادات الجدار الناري")

remote_executor.py

@@ -0,0 +1,104 @@
+# remote_executor.py (مُحدَّث: يدعم التشفير والتوقيع واختيار السيرفر ديناميكياً)
+# ============================================================
+# يرسل المهمّة إلى سيرفر RPC خارجي مع تشفير + توقيع،
+# أو يعمل بوضع JSON صافٍ لو لم يكن SecurityManager مفعَّل.
+# يستخدم قائمة الأقران المكتشفة لاختيار الـ endpoint بدل IP ثابت.
+# ============================================================
+
+import requests
+import json
+import os
+from typing import Any
+
+# قائمة الأقران (URLs) المستخرجة من peer_discovery
+from peer_discovery import PEERS
+
+# عنوان افتراضي احتياطي (يمكن تغييره بمتغير بيئي REMOTE_SERVER)
+FALLBACK_SERVER = os.getenv(
+    "REMOTE_SERVER",
+    "http://89.111.171.92:7520/run"
+)
+
+# محاولة استيراد SecurityManager (اختياري)
+try:
+    from security_layer import SecurityManager
+    security = SecurityManager(os.getenv("SHARED_SECRET", "my_shared_secret_123"))
+    SECURITY_ENABLED = True
+except ImportError:
+    security = None
+    SECURITY_ENABLED = False
+
+
+def _choose_remote_server() -> str:
+    """
+    يختار عنوان السيرفر الذي سترسل إليه المهمة:
+    1) إذا عُيّن متغير بيئي REMOTE_SERVER، يُستخدم.
+    2) وإلا إذا اكتشفنا أقران عبر LAN/Internet، نأخذ أولهم.
+    3) وإلا نعود إلى FALLBACK_SERVER.
+    """
+    env_url = os.getenv("REMOTE_SERVER")
+    if env_url:
+        return env_url.rstrip('/') + '/run'
+    # PEERS يحوي عناوين كاملة من نوع http://ip:port/run
+    if PEERS:
+        # نختار الحد الأدنى من التحميل (اختياري) أو أول عنصر
+        # هنا ببساطة نأخذ أول URL
+        return next(iter(PEERS))
+    # استخدام الافتراضي
+    return FALLBACK_SERVER.rstrip('/') + '/run'
+
+
+def execute_remotely(
+    func_name: str,
+    args: list[Any] | None = None,
+    kwargs: dict[str, Any] | None = None
+) -> Any:
+    """إرسال استدعاء دالة إلى الخادم البعيد وإرجاع النتيجة."""
+    if args is None:
+        args = []
+    if kwargs is None:
+        kwargs = {}
+
+    task = {
+        "func": func_name,
+        "args": args,
+        "kwargs": kwargs,
+        "sender_id": "client_node"
+    }
+
+    # اختيار السيرفر الصحيح ديناميكياً
+    target_url = _choose_remote_server()
+
+    try:
+        if SECURITY_ENABLED:
+            # 1) وقّع المهمة ثم شفّرها
+            signed_task = security.sign_task(task)
+            encrypted   = security.encrypt_data(json.dumps(signed_task).encode())
+
+            headers = {
+                "X-Signature": security.signature_hex,
+                "Content-Type": "application/octet-stream"
+            }
+            payload = encrypted  # خام ثنائي
+            resp = requests.post(
+                target_url,
+                headers=headers,
+                data=payload,
+                timeout=15
+            )
+        else:
+            # وضع التطوير: أرسل JSON صريح
+            headers = {"Content-Type": "application/json"}
+            resp = requests.post(
+                target_url,
+                headers=headers,
+                json=task,
+                timeout=15
+            )
+
+        resp.raise_for_status()
+        data = resp.json()
+        return data.get("result", "⚠️ لا يوجد نتيجة")
+
+    except Exception as e:
+        return f"❌ فشل التنفيذ البعيد على {target_url}: {e}"

replit.md

@@ -0,0 +1,108 @@
+# Distributed Task System (DTS)
+
+## Overview
+
+The Distributed Task System (DTS) is a full-stack web application that manages distributed computing across multiple nodes. It features a React frontend with shadcn/ui components and an Express.js backend with PostgreSQL database integration via Drizzle ORM. The system enables peer discovery, task distribution, load balancing, and real-time monitoring of distributed computing resources.
+
+## System Architecture
+
+### Frontend Architecture
+- **Framework**: React 18 with TypeScript
+- **Build Tool**: Vite with custom configuration
+- **UI Library**: shadcn/ui components built on Radix UI primitives
+- **Styling**: Tailwind CSS with custom dark theme
+- **State Management**: TanStack Query for server state management
+- **Routing**: Wouter for lightweight client-side routing
+- **Real-time Updates**: WebSocket connection for live system monitoring
+
+### Backend Architecture
+- **Runtime**: Node.js with Express.js framework
+- **Database**: PostgreSQL with Drizzle ORM
+- **Real-time Communication**: WebSocket Server for live updates
+- **Task Execution**: Custom task executor with built-in operations
+- **Peer Discovery**: Bonjour/mDNS-based service discovery
+- **Security**: Custom security manager with encryption and digital signatures
+
+### Key Components
+
+#### Database Schema
+- **Nodes Table**: Stores information about connected computing nodes (id, name, ip, port, status, load, capabilities)
+- **Tasks Table**: Manages distributed tasks (id, name, status, nodeId, complexity, duration, result, error)
+- **System Metrics Table**: Tracks performance metrics (nodeId, cpuUsage, memoryUsage, timestamp)
+- **System Logs Table**: Centralized logging (level, message, source, nodeId, timestamp)
+
+#### Services
+- **OffloadSystem**: Orchestrates task distribution and peer management
+- **PeerDiscovery**: Uses Bonjour protocol for automatic node discovery on the network
+- **TaskExecutor**: Handles built-in tasks like matrix multiplication, prime calculation, and data processing
+- **SecurityManager**: Manages payload encryption, digital signatures, and secure communication
+- **SystemMonitor**: Tracks system performance and resource utilization
+
+#### Frontend Components
+- **Dashboard**: Main interface showing system overview and metrics
+- **MetricsGrid**: Real-time system performance visualization
+- **NodesTable**: Connected nodes management interface
+- **TaskActivity**: Task execution monitoring and status tracking
+- **SecurityPanel**: Security status indicators
+- **SystemLogs**: Centralized log viewing interface
+
+## Data Flow
+
+1. **Node Registration**: Nodes automatically discover and register with the system via mDNS
+2. **Task Submission**: Tasks are submitted through the web interface or API
+3. **Load Balancing**: System evaluates node capacity and distributes tasks accordingly
+4. **Task Execution**: Tasks are executed on selected nodes with real-time status updates
+5. **Result Collection**: Results are collected and stored in the database
+6. **Real-time Updates**: WebSocket connections push updates to connected clients
+
+## External Dependencies
+
+### Production Dependencies
+- **Database**: @neondatabase/serverless for PostgreSQL connection
+- **ORM**: drizzle-orm and drizzle-zod for database operations
+- **UI Components**: @radix-ui/* packages for accessible UI primitives
+- **Networking**: bonjour-service for peer discovery
+- **Real-time**: ws (WebSocket) for live updates
+- **Query Management**: @tanstack/react-query for server state
+- **Session Management**: connect-pg-simple for session storage
+
+### Development Dependencies
+- **Build Tools**: Vite, esbuild for production builds
+- **Type Safety**: TypeScript with strict configuration
+- **Code Quality**: ESLint integration (implied by tsconfig)
+- **Development Experience**: @replit/vite-plugin-runtime-error-modal and cartographer
+
+## Deployment Strategy
+
+### Development Mode
+- Frontend served via Vite dev server with HMR
+- Backend runs with tsx for TypeScript execution
+- Database migrations handled via drizzle-kit push
+- Automatic service discovery in local network
+
+### Production Build
+1. Frontend built with Vite to `dist/public`
+2. Backend compiled with esbuild to `dist/index.js`
+3. Single Node.js process serves both static files and API
+4. PostgreSQL database connection via environment variables
+5. WebSocket server integrated with HTTP server
+
+### Environment Configuration
+- `DATABASE_URL`: PostgreSQL connection string (required)
+- `NODE_ENV`: Environment mode (development/production)
+- `NODE_NAME`: Custom node identifier
+- `SHARED_SECRET`: Security encryption key
+
+## Changelog
+- June 29, 2025. Initial setup
+- June 29, 2025. Added broadcast messaging capability to send messages to all connected devices from the index page
+  - Created broadcast_messages table in PostgreSQL database
+  - Implemented API endpoints for sending and retrieving broadcast messages  
+  - Added real-time WebSocket broadcasting to all connected clients
+  - Created bilingual UI components with Arabic interface
+  - Added navigation link in sidebar for easy access
+  - Integrated with existing authentication and security systems
+
+## User Preferences
+
+Preferred communication style: Simple, everyday language.

requirements.txt

@@ -0,0 +1,8 @@
+Flask
+flask_cors
+requests
+psutil
+zeroconf
+cryptography
+numpy
+networkx

rpc_server.py

@@ -0,0 +1,73 @@
+# rpc_server.py (مُحدَّث بحيث يدعم التشفير الاختياري)
+# ============================================================
+# خادِم يستقبل مهام عن بُعد:
+#   • إن وصلته بيانات خام (Encrypted) في Body → يفك تشفيرها ويتحقق من التوقيع.
+#   • وإلا إن وصل JSON خام في Content‑Type: application/json → ينفّذ مباشرة (وضع تطويـر).
+# ============================================================
+
+from flask import Flask, request, jsonify
+import smart_tasks  # «your_tasks» تمّ استيراده تحت هذا الاسم فى main.py
+import logging, json
+from security_layer import SecurityManager
+
+SECURITY = SecurityManager("my_shared_secret_123")
+
+logging.basicConfig(
+    filename="server.log",
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s"
+)
+
+app = Flask(name)
+
+# ------------------------------------------------------------------
+@app.route("/health")
+def health():
+    return jsonify(status="ok")
+
+# ------------------------------------------------------------------
+@app.route("/run", methods=["POST"])
+def run():
+    try:
+        # 1) حاول قراءة كـ JSON مباشر (وضع التطويـر)
+        if request.is_json:
+            data = request.get_json()
+        else:
+            # 2) وإلا اعتبره Payload مُشفَّر (وضع الإنتاج)
+            encrypted = request.get_data()
+            try:
+                decrypted = SECURITY.decrypt_data(encrypted)
+                data = json.loads(decrypted.decode())
+            except Exception as e:
+                logging.error(f"⚠️ فشل فك التشفير: {e}")
+                return jsonify(error="Decryption failed"), 400
+
+        # 3) التحقّق من التوقيع إن وُجد
+        if "_signature" in data:
+            if not SECURITY.verify_task(data):
+                logging.warning("❌ توقيع غير صالح")
+                return jsonify(error="Invalid signature"), 403
+            # أزل عناصر موقّعة إضافية
+            data = {k: v for k, v in data.items() if k not in ("_signature", "sender_id")}
+
+        func_name = data.get("func")
+        args      = data.get("args", [])
+        kwargs    = data.get("kwargs", {})
+
+        fn = getattr(smart_tasks, func_name, None)
+        if not fn:
+            logging.warning(f"❌ لم يتم العثور على الدالة: {func_name}")
+            return jsonify(error="Function not found"), 404
+
+        logging.info(f"⚙️ تنفيذ الدالة: {func_name} من جهاز آخر")
+        result = fn(*args, **kwargs)
+        return jsonify(result=result)
+
+    except Exception as e:
+        logging.error(f"🔥 خطأ أثناء تنفيذ المهمة: {str(e)}")
+        return jsonify(error=str(e)), 500
+
+# ------------------------------------------------------------------
+if name == "main":
+    # تأكد أن المنفذ 7520 مفتوح
+    app.run(host="0.0.0.0", port=7520)

run_task.py

@@ -0,0 +1,22 @@
+@flask_app.route("/run_task", methods=["POST"])
+def run_task():
+    task_id = request.form.get("task_id")
+    result = None
+      # قبول البيانات سواء كانت JSON أو form-urlencoded
+    if request.is_json:
+        data = request.get_json()
+        task_id = data.get("task_id")
+    else:
+        task_id = request.form.get("task_id")
+    
+    if not task_id:
+        return jsonify(error="Missing task_id"), 400
+
+    if task_id == "1":
+        result = matrix_multiply(500)
+    elif task_id == "2":
+        result = prime_calculation(100_000)
+    elif task_id == "3":
+        result = data_processing(10_000)
+    
+    return jsonify(result=result)  # إرجاع JSON بدل HTML

security_layer.py

@@ -0,0 +1,120 @@
+# security_layer.py (مُحدَّث)
+# ============================================================
+# إدارة التشفير والتوقيع وتبادل المفاتيح بين العقد
+# ============================================================
+
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.hazmat.primitives.asymmetric import rsa, padding
+from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+from cryptography.fernet import Fernet
+import os, base64, json
+from typing import Dict
+
+
+class SecurityManager:
+    """طبقة أمان موحّدة لكل العقد."""
+
+    def __init__(self, shared_secret: str):
+        # مفتاح متماثل لاستخدام Fernet
+        self._key = self._derive_key(shared_secret)
+        self._cipher = Fernet(self._key)
+
+        # زوج مفاتيح غير متماثل للتوقيع الرقمي
+        self._private_key = rsa.generate_private_key(
+            public_exponent=65537,
+            key_size=2048,
+        )
+        self._public_pem = (
+            self._private_key.public_key()
+            .public_bytes(
+                encoding=serialization.Encoding.PEM,
+                format=serialization.PublicFormat.SubjectPublicKeyInfo,
+            )
+            .decode()
+        )
+        # مفاتيح العقد الأخرى {peer_id: public_key_obj}
+        self._peer_keys: Dict[str, rsa.RSAPublicKey] = {}
+
+    # ------------------------------------------------------------
+    # تشفير / فك تشفير متماثل
+    # ------------------------------------------------------------
+    def encrypt_data(self, data: bytes) -> bytes:
+        return self._cipher.encrypt(data)
+
+    def decrypt_data(self, encrypted: bytes) -> bytes:
+        return self._cipher.decrypt(encrypted)
+
+    # ------------------------------------------------------------
+    # توقيع/تحقّق رقمي غير متماثل
+    # ------------------------------------------------------------
+    def sign_task(self, task: Dict) -> Dict:
+        """يُرجع نسخة موقّعة من الـtask مضافًا إليها المفتاح العام والمعرّف."""
+        signature = self._private_key.sign(
+            json.dumps(task, separators=(",", ":")).encode(),
+            padding.PSS(
+                mgf=padding.MGF1(hashes.SHA256()),
+                salt_length=padding.PSS.MAX_LENGTH,
+            ),
+            hashes.SHA256(),
+        )
+        task_signed = task.copy()
+        task_signed.update(
+            {
+                "_signature": base64.b64encode(signature).decode(),
+                "sender_id": os.getenv("NODE_ID", "unknown"),
+                "sender_key": self._public_pem,
+            }
+        )
+        return task_signed
+
+    def verify_task(self, signed_task: Dict) -> bool:
+        """يتحقق من صحة التوقيع باستخدام المفتاح العام للمرسل."""
+        if "_signature" not in signed_task or "sender_id" not in signed_task:
+            return False
+        sig = base64.b64decode(signed_task["_signature"])
+        task_copy = {k: v for k, v in signed_task.items() if k not in {"_signature", "sender_key"}}
+
+        peer_id = signed_task["sender_id"]
+        if peer_id not in self._peer_keys:
+            # حاول إضافة المفتاح المرسل إن وجد
+            if "sender_key" in signed_task:
+                self.add_peer_key(peer_id, signed_task["sender_key"])
+            else:
+                return False
+        try:
+            self._peer_keys[peer_id].verify(
+                sig,
+                json.dumps(task_copy, separators=(",", ":")).encode(),
+                padding.PSS(
+                    mgf=padding.MGF1(hashes.SHA256()),
+                    salt_length=padding.PSS.MAX_LENGTH,
+                ),
+                hashes.SHA256(),
+            )
+            return True
+        except Exception:
+            return False
+
+    # ------------------------------------------------------------
+    # إدارة المفاتيح العامة للأقران
+    # ------------------------------------------------------------
+    def add_peer_key(self, peer_id: str, public_key_pem: str):
+        """تخزين/تحديث المفتاح العام لعقدة أخرى."""
+        self._peer_keys[peer_id] = serialization.load_pem_public_key(
+            public_key_pem.encode()
+        )
+
+    # ------------------------------------------------------------
+    # أدوات داخلية
+    # ------------------------------------------------------------
+    @staticmethod
+    def _derive_key(password: str) -> bytes:
+        salt = b"nora_salt_2025"  # ◀️ عدِّل في الإنتاج
+        kdf = PBKDF2HMAC(
+            algorithm=hashes.SHA256(),
+            length=32,
+            salt=salt,
+            iterations=150_000,
+        )
+        return base64.urlsafe_b64encode(kdf.derive(password.encode()))
+

server.py

@@ -0,0 +1,32 @@
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+import json
+from your_tasks import *
+from project_identifier import create_project_endpoint, get_project_info
+import logging
+
+app = Flask(__name__)
+CORS(app)
+
+@app.route('/multiply', methods=['POST'])
+def multiply():
+    try:
+        data = request.get_json()
+        a = data.get("a", 0)
+        b = data.get("b", 0)
+        result_dict = multiply_task(a, b)  # دالة offload
+        return jsonify({"result": result_dict["result"]})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/health', methods=['GET'])
+def health_check():
+    return jsonify({"status": "healthy", "port": 7520})
+
+@app.route('/project_info', methods=['GET'])
+def project_info():
+    return create_project_endpoint()
+
+if __name__ == "__main__":
+    # هذا العنوان يسمح بالاستماع على IP خارجي لتلقي الاتصالات من الإنترنت
+    app.run(host="0.0.0.0", port=7520)

setup.py

@@ -0,0 +1,69 @@
+# setup.py
+import configparser
+# Monkey-patch for Python 3: define SafeConfigParser for stdeb compatibility
+configparser.SafeConfigParser = configparser.RawConfigParser
+
+from setuptools import setup, find_packages
+
+# Load long description from README
+with open("README.md", encoding="utf-8") as f:
+    long_desc = f.read()
+
+setup(
+    name="distributed-task-system",
+    version="1.0",
+    description="A simple distributed task offload system",
+    long_description=long_desc,
+    long_description_content_type="text/markdown",
+    author="Osama Awartany",
+    author_email="osama@example.com",
+    url="https://github.com/yourusername/distributed-task-system",
+    packages=find_packages(include=["offload_core", "offload_core.*"]),
+    py_modules=["dts_cli"],  # Include the CLI helper module
+    install_requires=[
+        "flask",
+        "requests",
+        "psutil",
+        "zeroconf",
+        "flask_cors",
+        "numpy",
+        "uvicorn"
+    ],
+    entry_points={
+        "console_scripts": [
+            "dts-start=dts_cli:main",
+        ],
+    },
+    data_files=[
+        ("/etc/systemd/system", ["dts.service"])
+    ],
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: POSIX :: Linux",
+    ],
+    python_requires='>=3.6',
+)
+
+
+# dts_cli.py
+# CLI entry-point module for the Distributed Task System
+# Place this next to setup.py
+
+def main():
+    """
+    Main entry for dts-start console script.
+    Launches the FastAPI/Flask app via Uvicorn.
+    """
+    # Import your application instance here:
+    try:
+        from offload_core.main import app
+    except ImportError:
+        # If you have a factory, adjust accordingly:
+        from offload_core.main import create_app
+        app = create_app()
+
+    # Run with Uvicorn
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7520)
+

setup_fonts.py

@@ -0,0 +1,20 @@
+import os
+import requests
+
+FONT_DIR = "fonts"
+FONT_PATH = os.path.join(FONT_DIR, "Cairo-Regular.ttf")
+
+# 🔥 رابط مباشر من Google Fonts CDN - Cairo Regular وزن 400
+URL = "https://fonts.cdnfonts.com/s/12667/Cairo-Regular.woff"
+
+os.makedirs(FONT_DIR, exist_ok=True)
+
+print("[+] تحميل الخط Cairo-Regular...")
+response = requests.get(URL)
+if response.status_code == 200:
+    with open(FONT_PATH, "wb") as f:
+        f.write(response.content)
+    print(f"[✅] تم حفظ الخط في {FONT_PATH}")
+else:
+    print(f"[❌] فشل تحميل الخط! كود الحالة: {response.status_code}")
+

simple_assistant.py

@@ -0,0 +1,101 @@
+
+# -*- coding: utf-8 -*-
+
+import os
+import json
+import random
+import re
+from datetime import datetime
+
+class SimpleNoraAssistant:
+    def __init__(self):
+        self.history_path = "simple_history.json"
+        self.chat_history = self.load_history()
+        self.knowledge_base = {
+            "تحية": ["مرحباً!", "أهلاً وسهلاً!", "كيف حالك؟"],
+            "وقت": [f"الوقت الحالي: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"],
+            "مساعدة": ["يمكنني مساعدتك في الأسئلة البسيطة والدردشة!", "اسألني أي سؤال وسأحاول المساعدة!"],
+            "برمجة": ["البرمجة مهارة رائعة!", "ما نوع البرمجة التي تريد تعلمها؟"],
+            "افتراضي": ["مثير للاهتمام!", "حدثني أكثر عن ذلك.", "هذا سؤال جيد!"]
+        }
+    
+    def load_history(self):
+        """تحميل سجل المحادثة"""
+        if os.path.exists(self.history_path):
+            try:
+                with open(self.history_path, "r", encoding="utf-8") as f:
+                    return json.load(f)
+            except:
+                return []
+        return []
+    
+    def save_history(self):
+        """حفظ سجل المحادثة"""
+        with open(self.history_path, "w", encoding="utf-8") as f:
+            json.dump(self.chat_history, f, ensure_ascii=False, indent=2)
+    
+    def get_response(self, user_input: str) -> str:
+        """الحصول على رد بسيط"""
+        user_input = user_input.lower().strip()
+        
+        # تحديد نوع السؤال
+        if any(word in user_input for word in ["مرحبا", "أهلا", "السلام"]):
+            category = "تحية"
+        elif any(word in user_input for word in ["وقت", "تاريخ", "ساعة"]):
+            category = "وقت"
+        elif any(word in user_input for word in ["مساعدة", "help"]):
+            category = "مساعدة"
+        elif any(word in user_input for word in ["برمجة", "كود", "programming"]):
+            category = "برمجة"
+        else:
+            category = "افتراضي"
+        
+        # اختيار رد عشوائي من الفئة
+        responses = self.knowledge_base.get(category, self.knowledge_base["افتراضي"])
+        return random.choice(responses)
+    
+    def learn_from_input(self, user_input: str, user_response: str):
+        """تعلم بسيط من المدخلات"""
+        # إضافة ردود جديدة بناءً على تفاعل المستخدم
+        if "جيد" in user_response.lower() or "شكرا" in user_response.lower():
+            print("نورا: سعيدة أنني ساعدتك!")
+    
+    def simulate_server_scan(self):
+        """محاكاة البحث عن الخوادم"""
+        print("نورا: أبحث عن خوادم...")
+        fake_servers = ["192.168.1.5", "192.168.1.10", "192.168.1.20"]
+        for server in fake_servers:
+            print(f"نورا: تم العثور على خادم مفتوح في {server}")
+            print(f"نورا: أقوم بنسخ نفسي إلى {server} (محاكاة فقط)...")
+    
+    def chat(self):
+        """بدء المحادثة"""
+        print("مرحباً! أنا نورا، مساعدتك البسيطة. اكتب 'خروج' للإنهاء أو 'scan' للبحث عن خوادم.")
+        
+        while True:
+            user_input = input("\nأنت: ").strip()
+            
+            if user_input.lower() in ["خروج", "exit", "quit"]:
+                print("نورا: مع السلامة!")
+                break
+            elif user_input.lower() == "scan":
+                self.simulate_server_scan()
+                continue
+            elif not user_input:
+                continue
+            
+            # الحصول على الرد
+            response = self.get_response(user_input)
+            print(f"نورا: {response}")
+            
+            # حفظ في السجل
+            self.chat_history.append({
+                "timestamp": datetime.now().isoformat(),
+                "user": user_input,
+                "assistant": response
+            })
+            self.save_history()
+
+if __name__ == "__main__":
+    assistant = SimpleNoraAssistant()
+    assistant.chat()

simple_history.json

@@ -0,0 +1,12 @@
+[
+  {
+    "timestamp": "2025-08-01T04:07:49.526870",
+    "user": "مرحبا",
+    "assistant": "مرحباً!"
+  },
+  {
+    "timestamp": "2025-08-01T04:07:56.868610",
+    "user": "كيف حالك",
+    "assistant": "هذا سؤال جيد!"
+  }
+]

smart_tasks.py

@@ -0,0 +1,138 @@
+import math
+import numpy as np
+import time
+
+def prime_calculation(n: int):
+    """ترجع قائمة الأعداد الأوليّة حتى n مع عددها"""
+    primes = []
+    for num in range(2, n + 1):
+        if all(num % p != 0 for p in range(2, int(math.sqrt(num)) + 1)):
+            primes.append(num)
+    return {"count": len(primes), "primes": primes}
+
+def matrix_multiply(size: int):
+    """ضرب مصفوفات عشوائيّة (size × size)"""
+    A = np.random.rand(size, size)
+    B = np.random.rand(size, size)
+    result = np.dot(A, B)  # يمكن أيضًا: A @ B
+    return {"result": result.tolist()}
+
+def data_processing(data_size: int):
+    """تنفيذ معالجة بيانات بسيطة كتجربة"""
+    data = np.random.rand(data_size)
+    mean = np.mean(data)
+    std_dev = np.std(data)
+    return {"mean": mean, "std_dev": std_dev}
+
+def image_processing_emulation(iterations):
+    """محاكاة معالجة الصور"""
+    results = []
+    for i in range(iterations):
+        fake_processing = sum(math.sqrt(x) for x in range(i * 100, (i + 1) * 100))
+        results.append(fake_processing)
+        time.sleep(0.01)
+    return {"iterations": iterations, "results": results}
+
+# مهام معالجة الفيديو والألعاب ثلاثية الأبعاد
+def video_format_conversion(duration_seconds, quality_level, input_format="mp4", output_format="avi"):
+    """تحويل صيغة الفيديو"""
+    import time
+    start_time = time.time()
+    processing_time = duration_seconds * quality_level * 0.05  # معالجة أسرع للخادم
+    time.sleep(min(processing_time, 1))  # محدود بثانية واحدة
+
+    return {
+        "status": "success",
+        "input_format": input_format,
+        "output_format": output_format,
+        "duration": duration_seconds,
+        "quality": quality_level,
+        "processing_time": time.time() - start_time,
+        "server_processed": True
+    }
+
+def video_effects_processing(video_length, effects_count, resolution="1080p"):
+    """معالجة تأثيرات الفيديو"""
+    import time
+    start_time = time.time()
+
+    resolution_multiplier = {"480p": 1, "720p": 2, "1080p": 3, "4K": 5}
+    multiplier = resolution_multiplier.get(resolution, 2)
+    processing_time = video_length * effects_count * multiplier * 0.03
+
+    time.sleep(min(processing_time, 1.5))
+
+    return {
+        "status": "success",
+        "video_length": video_length,
+        "effects_count": effects_count,
+        "resolution": resolution,
+        "processing_time": time.time() - start_time,
+        "server_processed": True
+    }
+
+def render_3d_scene(objects_count, resolution_width, resolution_height, 
+                   lighting_quality="medium", texture_quality="high"):
+    """رندر مشهد ثلاثي الأبعاد"""
+    import time
+    start_time = time.time()
+
+    complexity = objects_count * (resolution_width * resolution_height) / 2000000  # تقليل التعقيد للخادم
+    processing_time = complexity * 0.02
+
+    time.sleep(min(processing_time, 2))
+
+    fps = max(30, 120 - (complexity * 5))  # أداء أفضل للخادم
+
+    return {
+        "status": "success",
+        "objects_rendered": objects_count,
+        "resolution": f"{resolution_width}x{resolution_height}",
+        "lighting_quality": lighting_quality,
+        "texture_quality": texture_quality,
+        "estimated_fps": round(fps, 1),
+        "processing_time": time.time() - start_time,
+        "server_processed": True
+    }
+
+def physics_simulation(objects_count, frames_count, physics_quality="medium"):
+    """محاكاة الفيزياء"""
+    import time
+    start_time = time.time()
+
+    quality_multiplier = {"low": 1, "medium": 2, "high": 4, "ultra": 8}
+    multiplier = quality_multiplier.get(physics_quality, 2)
+
+    calculations = objects_count * frames_count * multiplier
+    processing_time = calculations / 200000  # أسرع للخادم
+
+    time.sleep(min(processing_time, 1.5))
+
+    return {
+        "status": "success",
+        "objects_simulated": objects_count,
+        "frames_processed": frames_count,
+        "physics_quality": physics_quality,
+        "calculations_performed": calculations,
+        "processing_time": time.time() - start_time,
+        "server_processed": True
+    }
+
+def game_ai_processing(ai_agents_count, decision_complexity, game_state_size):
+    """معالجة ذكاء اصطناعي للألعاب"""
+    import time
+    start_time = time.time()
+
+    total_operations = ai_agents_count * decision_complexity * game_state_size
+    processing_time = total_operations / 100000  # أسرع للخادم
+
+    time.sleep(min(processing_time, 1))
+
+    return {
+        "status": "success",
+        "ai_agents": ai_agents_count,
+        "decision_complexity": decision_complexity,
+        "total_operations": total_operations,
+        "processing_time": time.time() - start_time,
+        "server_processed": True
+    }

startup.py

@@ -0,0 +1,105 @@
+import subprocess
+import time
+import logging
+import sys
+from autostart_config import AutoStartManager
+from distributed_executor import DistributedExecutor
+
+PY = sys.executable  # مسار بايثون الحالي
+
+SERVICES = [
+    ("peer_server.py", "Peer‑Server"),
+    ("rpc_server.py", "RPC‑Server"),
+    ("server.py", "REST‑Server"),  # يعمل على 7521 حاليًا
+    ("load_balancer.py", "Load‑Balancer"),
+]
+
+
+def launch_services():
+    procs = []
+    for script, name in SERVICES:
+        try:
+            p = subprocess.Popen([PY, script])
+            logging.info(f"✅ {name} قيد التشغيل (PID={p.pid})")
+            procs.append(p)
+        except FileNotFoundError:
+            logging.error(f"❌ لم يُعثَر على {script}; تخطَّيته")
+            return procs
+
+
+def main():
+    # إعداد السجلات مع دعم وضع الخلفية
+    import os
+
+    # إنشاء مجلد السجلات
+    os.makedirs("logs", exist_ok=True)
+
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(levelname)s - %(message)s",
+        handlers=[
+            logging.FileHandler("logs/startup.log"),
+            logging.StreamHandler()  # إظهار السجلات في وحدة التحكم أيضاً
+        ]
+    )
+
+    try:
+        cfg = AutoStartManager().config
+        if not cfg.get("enabled", True):
+            logging.info("التشغيل التلقائي مُعطل في الإعدادات")
+            return
+
+        # فحص إذا كانت الخدمة الخلفية متاحة
+        background_service_available = os.path.exists("background_service.py")
+
+        if background_service_available:
+            logging.info("🔄 تشغيل الخدمة الخلفية المحسّنة...")
+            # تشغيل الخدمة الخلفية الجديدة
+            try:
+                subprocess.Popen([PY, "background_service.py", "start"])
+                logging.info("✅ تم بدء تشغيل الخدمة الخلفية المحسّنة")
+                return
+            except Exception as e:
+                logging.warning(f"⚠️ فشل في تشغيل الخدمة الخلفية المحسّنة: {e}")
+                logging.info("🔄 العودة إلى الطريقة التقليدية...")
+
+        # الطريقة التقليدية (fallback)
+        logging.info("🚀 تشغيل الخدمات بالطريقة التقليدية...")
+
+        # 1) تشغيل الخدمات الخلفيّة
+        procs = launch_services()
+
+        # 2) تهيئة نظام التنفيذ الموزع (ليتعرّف على هذا الجهاز كعقدة)
+        executor = DistributedExecutor("my_shared_secret_123")
+        executor.peer_registry.register_service("auto_node", 7520)
+        logging.info("🚀 العقدة auto_node مُسجّلة في الـRegistry على 7520")
+
+        # 3) حلقة إبقاء حيّة مع فحص العمليات
+        while True:
+            time.sleep(30)
+            for p, (script, name) in zip(procs, SERVICES):
+                if p.poll() is not None:
+                    logging.warning(f"⚠️ الخدمة {name} توقفت بشكل غير متوقع… إعادة تشغيل")
+                    new_p = subprocess.Popen([PY, script])
+                    procs[procs.index(p)] = new_p
+                    logging.info(f"✅ {name} أُعيد تشغيلها (PID={new_p.pid})")
+
+    except KeyboardInterrupt:
+        logging.info("📴 إيقاف الخدمات يدويًا")
+    except Exception as e:
+        logging.error(f"خطأ في التشغيل التلقائي: {e}")
+    finally:
+        # إيقاف العمليات بأمان
+        try:
+            for p in procs:
+                p.terminate()
+                try:
+                    p.wait(timeout=5)
+                except subprocess.TimeoutExpired:
+                    p.kill()
+        except:
+            pass
+
+
+if __name__ == "main":
+    main()

system_check.py

@@ -0,0 +1,111 @@
+
+#!/usr/bin/env python3
+# system_check.py - فحص سريع لحالة النظام
+
+import time
+import requests
+import psutil
+import threading
+from offload_lib import discover_peers
+
+def check_local_system():
+    """فحص النظام المحلي"""
+    print("🔍 فحص النظام المحلي...")
+    cpu = psutil.cpu_percent(interval=1)
+    memory = psutil.virtual_memory()
+    
+    print(f"⚡ CPU: {cpu}%")
+    print(f"💾 الذاكرة: {memory.percent}%")
+    
+    return cpu < 80 and memory.percent < 90
+
+def check_server_running():
+    """فحص إذا كان الخادم المحلي يعمل"""
+    print("🌐 فحص الخادم المحلي...")
+    try:
+        response = requests.get("http://localhost:7520/health", timeout=3)
+        if response.status_code == 200:
+            print("✅ الخادم المحلي يعمل بشكل صحيح")
+            return True
+        else:
+            print("⚠️ الخادم يستجيب لكن بخطأ")
+            return False
+    except:
+        print("❌ الخادم المحلي غير متاح")
+        return False
+
+def check_peer_discovery():
+    """فحص اكتشاف الأجهزة"""
+    print("🔍 فحص اكتشاف الأجهزة...")
+    try:
+        peers = discover_peers(timeout=2)
+        if peers:
+            print(f"✅ تم اكتشاف {len(peers)} جهاز:")
+            for peer in peers[:3]:  # عرض أول 3 أجهزة فقط
+                print(f"   📱 {peer}")
+            return True
+        else:
+            print("⚠️ لم يتم اكتشاف أجهزة أخرى")
+            return False
+    except Exception as e:
+        print(f"❌ خطأ في اكتشاف الأجهزة: {e}")
+        return False
+
+def quick_task_test():
+    """اختبار مهمة سريعة"""
+    print("⚡ اختبار مهمة سريعة...")
+    try:
+        from offload_lib import matrix_multiply
+        start_time = time.time()
+        result = matrix_multiply(3)  # مصفوفة صغيرة
+        duration = time.time() - start_time
+        
+        print(f"✅ تمت المعالجة في {duration:.2f} ثانية")
+        return True
+    except Exception as e:
+        print(f"❌ فشل في تنفيذ المهمة: {e}")
+        return False
+
+def main():
+    """الفحص الرئيسي"""
+    print("🚀 فحص سريع لحالة النظام")
+    print("=" * 40)
+    
+    checks = [
+        ("النظام المحلي", check_local_system),
+        ("الخادم المحلي", check_server_running),
+        ("اكتشاف الأجهزة", check_peer_discovery),
+        ("تنفيذ المهام", quick_task_test)
+    ]
+    
+    results = []
+    for name, check_func in checks:
+        print(f"\n📋 {name}:")
+        try:
+            result = check_func()
+            results.append((name, result))
+        except Exception as e:
+            print(f"❌ خطأ غير متوقع: {e}")
+            results.append((name, False))
+    
+    print("\n" + "=" * 40)
+    print("📊 نتائج الفحص:")
+    
+    all_good = True
+    for name, result in results:
+        status = "✅" if result else "❌"
+        print(f"   {status} {name}")
+        if not result:
+            all_good = False
+    
+    if all_good:
+        print("\n🎉 كل شيء يعمل بشكل ممتاز!")
+        print("💡 يمكنك الآن تشغيل: python test_distributed_system.py")
+    else:
+        print("\n⚠️ هناك مشاكل تحتاج إصلاح:")
+        print("   1. تأكد من تشغيل: python server.py")
+        print("   2. تحقق من الاتصال بالشبكة")
+        print("   3. راجع ملفات السجل")
+
+if __name__ == "__main__":
+    main()

system_tray.py

@@ -0,0 +1,172 @@
+
+#!/usr/bin/env python3
+"""
+أيقونة شريط النظام للتحكم في الخدمة الخلفية
+"""
+
+import sys
+import threading
+import requests
+import webbrowser
+from pathlib import Path
+
+try:
+    import pystray
+    from pystray import MenuItem as item
+    from PIL import Image, ImageDraw
+    TRAY_AVAILABLE = True
+except ImportError:
+    TRAY_AVAILABLE = False
+    print("⚠️ pystray غير متوفر، تشغيل بدون أيقونة النظام")
+
+class SystemTrayController:
+    def __init__(self):
+        self.base_url = "http://localhost:8888"
+        self.icon = None
+        
+    def create_icon_image(self):
+        """إنشاء صورة الأيقونة"""
+        # إنشاء صورة بسيطة 64x64
+        image = Image.new('RGB', (64, 64), color='blue')
+        draw = ImageDraw.Draw(image)
+        
+        # رسم دائرة بسيطة
+        draw.ellipse([16, 16, 48, 48], fill='white')
+        draw.ellipse([20, 20, 44, 44], fill='blue')
+        
+        return image
+        
+    def get_service_status(self):
+        """الحصول على حالة الخدمة"""
+        try:
+            response = requests.get(f"{self.base_url}/status", timeout=2)
+            return response.json()
+        except:
+            return None
+            
+    def start_services(self, icon, item):
+        """بدء تشغيل الخدمات"""
+        try:
+            requests.post(f"{self.base_url}/start", timeout=5)
+            self.update_menu()
+        except Exception as e:
+            print(f"فشل في بدء الخدمات: {e}")
+            
+    def stop_services(self, icon, item):
+        """إيقاف الخدمات"""
+        try:
+            requests.post(f"{self.base_url}/stop", timeout=5)
+            self.update_menu()
+        except Exception as e:
+            print(f"فشل في إيقاف الخدمات: {e}")
+            
+    def show_ui(self, icon, item):
+        """إظهار الواجهة التفاعلية"""
+        try:
+            requests.post(f"{self.base_url}/show-ui", timeout=5)
+            # فتح المتصفح
+            webbrowser.open('http://localhost:5173')
+        except Exception as e:
+            print(f"فشل في إظهار الواجهة: {e}")
+            
+    def hide_ui(self, icon, item):
+        """إخفاء الواجهة التفاعلية"""
+        try:
+            requests.post(f"{self.base_url}/hide-ui", timeout=5)
+        except Exception as e:
+            print(f"فشل في إخفاء الواجهة: {e}")
+            
+    def open_dashboard(self, icon, item):
+        """فتح لوحة التحكم"""
+        webbrowser.open('http://localhost:5173/dashboard')
+        
+    def show_status(self, icon, item):
+        """إظهار حالة النظام"""
+        status = self.get_service_status()
+        if status:
+            status_text = f"حالة النظام: {status['status']}\n"
+            status_text += f"الخدمات النشطة: {len([s for s in status['services'].values() if s == 'running'])}\n"
+            status_text += f"وقت التشغيل: {int(status['uptime'])} ثانية"
+            print(status_text)
+        else:
+            print("❌ لا يمكن الوصول للخدمة")
+            
+    def quit_app(self, icon, item):
+        """إنهاء التطبيق"""
+        self.stop_services(icon, item)
+        icon.stop()
+        
+    def update_menu(self):
+        """تحديث قائمة الأيقونة"""
+        if self.icon:
+            status = self.get_service_status()
+            is_running = status and status['status'] == 'running'
+            
+            menu = pystray.Menu(
+                item('حالة النظام', self.show_status),
+                item('---'),
+                item('إظهار الواجهة', self.show_ui),
+                item('إخفاء الواجهة', self.hide_ui),
+                item('لوحة التحكم', self.open_dashboard),
+                item('---'),
+                item('بدء الخدمات', self.start_services, enabled=not is_running),
+                item('إيقاف الخدمات', self.stop_services, enabled=is_running),
+                item('---'),
+                item('إنهاء', self.quit_app)
+            )
+            
+            self.icon.menu = menu
+            
+    def create_menu(self):
+        """إنشاء قائمة الأيقونة"""
+        return pystray.Menu(
+            item('حالة النظام', self.show_status),
+            item('---'),
+            item('إظهار الواجهة', self.show_ui),
+            item('إخفاء الواجهة', self.hide_ui),
+            item('لوحة التحكم', self.open_dashboard),
+            item('---'),
+            item('بدء الخدمات', self.start_services),
+            item('إيقاف الخدمات', self.stop_services),
+            item('---'),
+            item('إنهاء', self.quit_app)
+        )
+        
+    def run(self):
+        """تشغيل أيقونة شريط النظام"""
+        if not TRAY_AVAILABLE:
+            print("❌ مكتبة pystray غير متوفرة")
+            return
+            
+        # إنشاء الأيقونة
+        image = self.create_icon_image()
+        menu = self.create_menu()
+        
+        self.icon = pystray.Icon(
+            "نظام توزيع المهام",
+            image,
+            menu=menu
+        )
+        
+        # تحديث دوري للقائمة
+        def update_loop():
+            import time
+            while True:
+                time.sleep(5)
+                if self.icon and hasattr(self.icon, '_running') and self.icon._running:
+                    self.update_menu()
+                else:
+                    break
+                    
+        update_thread = threading.Thread(target=update_loop, daemon=True)
+        update_thread.start()
+        
+        print("🖱️ تشغيل أيقونة شريط النظام...")
+        self.icon.run()
+
+def main():
+    controller = SystemTrayController()
+    controller.run()
+
+if __name__ == "__main__":
+    main()

tailwind.config.ts

@@ -0,0 +1,90 @@
+import type { Config } from "tailwindcss";
+
+export default {
+  darkMode: ["class"],
+  content: ["./client/index.html", "./client/src/**/*.{js,jsx,ts,tsx}"],
+  theme: {
+    extend: {
+      borderRadius: {
+        lg: "var(--radius)",
+        md: "calc(var(--radius) - 2px)",
+        sm: "calc(var(--radius) - 4px)",
+      },
+      colors: {
+        background: "var(--background)",
+        foreground: "var(--foreground)",
+        card: {
+          DEFAULT: "var(--card)",
+          foreground: "var(--card-foreground)",
+        },
+        popover: {
+          DEFAULT: "var(--popover)",
+          foreground: "var(--popover-foreground)",
+        },
+        primary: {
+          DEFAULT: "var(--primary)",
+          foreground: "var(--primary-foreground)",
+        },
+        secondary: {
+          DEFAULT: "var(--secondary)",
+          foreground: "var(--secondary-foreground)",
+        },
+        muted: {
+          DEFAULT: "var(--muted)",
+          foreground: "var(--muted-foreground)",
+        },
+        accent: {
+          DEFAULT: "var(--accent)",
+          foreground: "var(--accent-foreground)",
+        },
+        destructive: {
+          DEFAULT: "var(--destructive)",
+          foreground: "var(--destructive-foreground)",
+        },
+        border: "var(--border)",
+        input: "var(--input)",
+        ring: "var(--ring)",
+        chart: {
+          "1": "var(--chart-1)",
+          "2": "var(--chart-2)",
+          "3": "var(--chart-3)",
+          "4": "var(--chart-4)",
+          "5": "var(--chart-5)",
+        },
+        sidebar: {
+          DEFAULT: "var(--sidebar-background)",
+          foreground: "var(--sidebar-foreground)",
+          primary: "var(--sidebar-primary)",
+          "primary-foreground": "var(--sidebar-primary-foreground)",
+          accent: "var(--sidebar-accent)",
+          "accent-foreground": "var(--sidebar-accent-foreground)",
+          border: "var(--sidebar-border)",
+          ring: "var(--sidebar-ring)",
+        },
+      },
+      keyframes: {
+        "accordion-down": {
+          from: {
+            height: "0",
+          },
+          to: {
+            height: "var(--radix-accordion-content-height)",
+          },
+        },
+        "accordion-up": {
+          from: {
+            height: "var(--radix-accordion-content-height)",
+          },
+          to: {
+            height: "0",
+          },
+        },
+      },
+      animation: {
+        "accordion-down": "accordion-down 0.2s ease-out",
+        "accordion-up": "accordion-up 0.2s ease-out",
+      },
+    },
+  },
+  plugins: [require("tailwindcss-animate"), require("@tailwindcss/typography")],
+} satisfies Config;