Upload 68 files

DeviceManager.py

@@ -0,0 +1,82 @@
+import subprocess
+import GPUtil
+import psutil
+import logging
+from peer_discovery import PORT
+
+logging.getLogger().setLevel(logging.CRITICAL)  # صامت
+
+class DeviceManager:
+    def __init__(self):
+        self.devices = {
+            "GPU": self._detect_gpus(),
+            "DSP": self._detect_dsps(),
+            "NIC": self._detect_nics(),
+            "STORAGE": self._detect_storage(),
+            "CAPTURE": self._detect_capture(),
+            "ACCELERATOR": self._detect_accelerators()
+        }
+
+    # ────────────── اكتشاف الكروت ──────────────
+    def _detect_gpus(self):
+        try:
+            return GPUtil.getGPUs()
+        except:
+            return []
+
+    def _detect_dsps(self):
+        try:
+            output = subprocess.check_output(["aplay", "-l"], stderr=subprocess.DEVNULL).decode()
+            return ["DSP_Audio"] if "card" in output.lower() else []
+        except:
+            return []
+
+    def _detect_nics(self):
+        try:
+            return list(psutil.net_if_addrs().keys())
+        except:
+            return []
+
+    def _detect_storage(self):
+        try:
+            output = subprocess.check_output(["lsblk", "-o", "NAME"], stderr=subprocess.DEVNULL).decode()
+            return output.split() if output else []
+        except:
+            return []
+
+    def _detect_capture(self):
+        try:
+            output = subprocess.check_output(["v4l2-ctl", "--list-devices"], stderr=subprocess.DEVNULL).decode()
+            return output.split(":")[0::2] if output else []
+        except:
+            return []
+
+    def _detect_accelerators(self):
+        # افتراض: في المستقبل يمكن إضافة اكتشاف حقيقي لـ FPGA/TPU
+        return []
+
+    # ────────────── فحص الحمل ──────────────
+    def get_device_load(self, device_type, index=0):
+        try:
+            if device_type == "GPU" and self.devices["GPU"]:
+                return self.devices["GPU"][index].load * 100
+            elif device_type == "DSP" and self.devices["DSP"]:
+                return 10  # افتراضي: ما في API للحمل
+            elif device_type == "NIC" and self.devices["NIC"]:
+                return psutil.net_io_counters().bytes_sent / (1024 * 1024)  # مثال بسيط
+            elif device_type == "STORAGE" and self.devices["STORAGE"]:
+                return psutil.disk_usage('/').percent
+            elif device_type == "CAPTURE" and self.devices["CAPTURE"]:
+                return 20  # افتراضي: حمل منخفض
+            elif device_type == "ACCELERATOR" and self.devices["ACCELERATOR"]:
+                return 15  # افتراضي
+            return 0
+        except:
+            return 0
+
+    # ────────────── منطق 30% / 70% ──────────────
+    def can_receive(self, device_type, index=0):
+        return self.get_device_load(device_type, index) <= 30
+
+    def should_offload(self, device_type, index=0):
+        return self.get_device_load(device_type, index) >= 70

README_FIXES.md

@@ -0,0 +1,61 @@
+    # AmalOffload v6 — Fix Pack
+
+    تم إنشاء نسخة مُرقّعة من المشروع مع إصلاحات أساسية تمنع الأعطال الفورية وتسهّل التشغيل.
+
+    ## ما الذي تم إصلاحه؟
+    - autostart_config.py: dedup import of PORT
+- background_service.py: dedup import of PORT
+- central_manager.py: dedup import of PORT
+- control.py: dedup import of PORT
+- dashboard.py: dedup import of PORT
+- DeviceManager.py: dedup import of PORT
+- distributed_executor.py: dedup import of PORT
+- dts_cli.py: dedup import of PORT
+- enhanced_assistant.py: dedup import of PORT
+- external_server.py: dedup import of PORT
+- internet_scanner.py: dedup import of PORT
+- launcher.py: dedup import of PORT
+- live_streaming.py: dedup import of PORT
+- load_balancer.py: dedup import of PORT
+- peer_registry.py: dedup import of PORT
+- peer_server.py: dedup import of PORT
+- remote_executor.py: dedup import of PORT
+- rpc_server.py: dedup import of PORT
+- security_layer.py: dedup import of PORT
+- server.py: dedup import of PORT
+- smart_tasks.py: dedup import of PORT
+- system_check.py: dedup import of PORT
+- system_tray.py: dedup import of PORT
+- task_splitter.py: dedup import of PORT
+- test_distributed_system.py: dedup import of PORT
+- test_monitor.py: dedup import of PORT
+- video_processing.py: dedup import of PORT
+- your_tasks.py: dedup import of PORT
+- control.py: fixed broken import line
+- dts_cli.py: rewritten to a minimal, valid CLI
+- ram_manager.py: removed BOM
+- templates/dashboard.html: created from index.html
+- config.py: added as a single source of truth for PORT
+
+    ## توصيات إضافية (يدويّة)
+    - أضِف `fastapi` و`uvicorn` إلى `requirements.txt` إذا أردت تشغيل `central_manager.py` (يستخدم FastAPI).
+    - وحّد استيراد المنفذ عبر:
+      ```python
+      from config import PORT
+      ```
+      واستبدل أي استخدام لـ `from peer_discovery import PORT, PORT` أو `CPU_PORT` حسب الحاجة.
+    - إن ظهرت مشكلة `TemplateNotFound: dashboard.html` فقد تم إنشاء `templates/dashboard.html` تلقائياً.
+    - يُفضّل تنظيف `requirements.txt` من التكرارات (انظر التوصيات في تقرير التدقيق).
+    - اختر نقطة دخول واحدة للمشروع (مثلاً: `launcher.py` أو `startup.py`) وتجنّب تشغيل أكثر من خادم في نفس العملية.
+
+    ## التشغيل السريع المقترح
+    1) ثبّت المتطلبات (الأساسية فقط):
+       ```bash
+       pip install flask flask_cors flask_socketio requests psutil zeroconf cryptography numpy networkx GPUtil python-dotenv
+       ```
+    2) شغّل الـ Dashboard وخادم RPC معاً:
+       ```bash
+       python dts_cli.py start
+       ```
+
+    بالتوفيق!

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()

auto_offload.py

@@ -0,0 +1,73 @@
+import subprocess
+import torch
+import GPUtil
+import psutil
+import logging
+
+logging.getLogger().setLevel(logging.CRITICAL)  # صامت تمامًا
+
+class DeviceManager:
+    def __init__(self):
+        self.gpus = self._detect_gpus()
+        self.dsps = self._detect_dsps()
+        # في المستقبل يمكن إضافة كروت أخرى بنفس النمط
+
+    def _detect_gpus(self):
+        """اكتشاف جميع الـ GPUs المتاحة"""
+        try:
+            return GPUtil.getGPUs()
+        except Exception:
+            return []
+
+    def _detect_dsps(self):
+        """تحقق من وجود DSP أو كروت صوتية"""
+        try:
+            output = subprocess.check_output(["aplay", "-l"], stderr=subprocess.DEVNULL).decode()
+            if "card" in output.lower():
+                return ["DSP_Audio"]
+            return []
+        except Exception:
+            return []
+
+    def get_device_load(self, device_type, index=0):
+        """إرجاع نسبة الحمل للجهاز"""
+        if device_type == "GPU" and self.gpus:
+            try:
+                return self.gpus[index].load * 100  # نسبة مئوية
+            except Exception:
+                return 0
+        elif device_type == "DSP" and self.dsps:
+            # هنا ما في API رسمية، نفترض DSP قليل الحمل دائمًا كمثال
+            return 10
+        return 0
+
+class AutoOffloadExecutor:
+    def __init__(self, executor):
+        self.executor = executor
+        self.devices = DeviceManager()
+
+    def _should_offload(self, device_type, index=0):
+        load = self.devices.get_device_load(device_type, index)
+        return load >= 70
+
+    def _can_receive(self, device_type, index=0):
+        load = self.devices.get_device_load(device_type, index)
+        return load <= 30
+
+    def submit_auto(self, task_func, *args, task_type=None, **kwargs):
+        """إرسال تلقائي حسب حالة الكروت"""
+        device_type = "CPU"  # افتراضي
+        if task_type == "video" and self.devices.gpus:
+            device_type = "GPU"
+        elif task_type == "audio" and self.devices.dsps:
+            device_type = "DSP"
+
+        if self._should_offload(device_type):
+            # حمل عالي → أرسل
+            self.executor.submit(task_func, *args, **kwargs)
+        elif self._can_receive(device_type):
+            # حمل منخفض → نفذ محليًا
+            task_func(*args, **kwargs)
+        else:
+            # حمل متوسط → نفذ محليًا
+            task_func(*args, **kwargs)

autostart_config.py

@@ -0,0 +1,129 @@
+import json
+import os
+import platform
+from pathlib import Path
+from peer_discovery import PORT
+
+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,283 @@
+
+#!/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
+from peer_discovery import PORT
+
+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,112 @@
+#!/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
+from peer_discovery import PORT
+
+# ---- إعداد FastAPI ----------------------------------------------------------
+app = FastAPI(title="Central Task Manager")
+
+# ---- نماذج البيانات --------------------------------------------------------
+
+class RegisterRequest(BaseModel):
+    """تسجيل أو تجديد ظهور العقدة."""
+    url: str          # مثلاً: "http://203.0.113.45:PORT/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"
+    }
+}

config.py

@@ -0,0 +1,7 @@
+# config.py — نقطة مركزية لإعدادات المشروع
+import os, random
+
+# مصدر الحقيقة الوحيد لمنفذ الخدمة
+PORT = int(os.getenv("CPU_PORT", os.getenv("PORT", "0")))
+if PORT == 0:
+    PORT = random.randint(5000, 9999)

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,60 @@
+import logging
+import socket
+import threading
+import psutil
+import GPUtil
+from flask import Flask, render_template
+from flask_socketio import SocketIO, emit
+from peer_discovery import PEERS
+from peer_discovery import PORT
+
+
+logging.basicConfig(level=logging.INFO)
+
+app = Flask(__name__)
+socketio = SocketIO(app, cors_allowed_origins="*")
+
+node_id = socket.gethostname()
+connected_peers_data = {}
+
+# ─────────────── جمع بيانات الحمل ───────────────
+def get_system_status():
+    cpu = psutil.cpu_percent()
+    ram = psutil.virtual_memory().percent
+    gpu_load = 0
+    try:
+        gpus = GPUtil.getGPUs()
+        if gpus:
+            gpu_load = gpus[0].load * 100
+    except:
+        pass
+    return {"cpu": cpu, "ram": ram, "gpu": gpu_load}
+
+# ─────────────── إرسال التحديثات ───────────────
+def broadcast_status():
+    while True:
+        status = get_system_status()
+        socketio.emit("status_update", {node_id: status}, broadcast=True)
+        socketio.sleep(5)
+
+# ─────────────── صفحة الواجهة ───────────────
+@app.route("/")
+def index():
+    return render_template("dashboard.html", peers=connected_peers_data)
+
+# ─────────────── استقبال تحديثات الحالة ───────────────
+@socketio.on("status_update")
+def handle_status_update(data):
+    connected_peers_data.update(data)
+    emit("update_peers", connected_peers_data, broadcast=True)
+
+# ─────────────── دردشة ───────────────
+@socketio.on("send_message")
+def handle_message(data):
+    emit("receive_message", data, broadcast=True)
+
+# ─────────────── تشغيل ───────────────
+if __name__ == "__main__":
+    threading.Thread(target=broadcast_status).start()
+    logging.info(f"🚀 تشغيل Dashboard على {node_id}")
+    socketio.run(app, host="0.0.0.0", port=7000)

distributed_executor.py

@@ -0,0 +1,257 @@
+import threading
+import queue
+import time
+from typing import Callable, Dict, List
+import socket
+from zeroconf import Zeroconf, ServiceBrowser, ServiceInfo
+import logging
+import requests
+import subprocess
+import psutil
+import GPUtil
+from processor_manager import ResourceMonitor
+from peer_discovery import PORT
+
+
+logging.basicConfig(level=logging.INFO)
+
+# ─────────────── Device Manager عام ───────────────
+class DeviceManager:
+    def __init__(self):
+        self.devices = {
+            "GPU": self._detect_gpus(),
+            "DSP": self._detect_dsps(),
+            "NIC": self._detect_nics(),
+            "STORAGE": self._detect_storage(),
+            "CAPTURE": self._detect_capture(),
+            "ACCELERATOR": self._detect_accelerators()
+        }
+
+    # اكتشاف الأجهزة
+    def _detect_gpus(self):
+        try:
+            return GPUtil.getGPUs()
+        except:
+            return []
+
+    def _detect_dsps(self):
+        try:
+            output = subprocess.check_output(["aplay", "-l"], stderr=subprocess.DEVNULL).decode()
+            return ["DSP_Audio"] if "card" in output.lower() else []
+        except:
+            return []
+
+    def _detect_nics(self):
+        try:
+            return list(psutil.net_if_addrs().keys())
+        except:
+            return []
+
+    def _detect_storage(self):
+        try:
+            output = subprocess.check_output(["lsblk", "-o", "NAME"], stderr=subprocess.DEVNULL).decode()
+            return output.split() if output else []
+        except:
+            return []
+
+    def _detect_capture(self):
+        try:
+            output = subprocess.check_output(["v4l2-ctl", "--list-devices"], stderr=subprocess.DEVNULL).decode()
+            return output.split(":")[0::2] if output else []
+        except:
+            return []
+
+    def _detect_accelerators(self):
+        # افتراضي: يمكن إضافة اكتشاف حقيقي مستقبلاً
+        return ["Accelerator_Device"]
+
+    # قياس الحمل
+    def get_device_load(self, device_type, index=0):
+        try:
+            if device_type == "GPU" and self.devices["GPU"]:
+                return self.devices["GPU"][index].load * 100
+            elif device_type == "DSP" and self.devices["DSP"]:
+                return 10  # افتراضي
+            elif device_type == "NIC" and self.devices["NIC"]:
+                return psutil.net_io_counters().bytes_sent / (1024 * 1024)  # MB sent كمثال
+            elif device_type == "STORAGE" and self.devices["STORAGE"]:
+                return psutil.disk_usage('/').percent
+            elif device_type == "CAPTURE" and self.devices["CAPTURE"]:
+                return 20  # افتراضي
+            elif device_type == "ACCELERATOR" and self.devices["ACCELERATOR"]:
+                return 15  # افتراضي
+            return 0
+        except:
+            return 0
+
+    # منطق الاستقبال/الإرسال
+    def can_receive(self, device_type, index=0):
+        return self.get_device_load(device_type, index) <= 30
+
+    def should_offload(self, device_type, index=0):
+        return self.get_device_load(device_type, index) >= 70
+
+# ─────────────── Peer Registry ───────────────
+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
+
+# ─────────────── Distributed Executor ───────────────
+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.devices = DeviceManager()
+        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, task_type=None, **kwargs):
+        monitor = ResourceMonitor().current_load()
+        avg_cpu = monitor["average"]["cpu"]
+        avg_mem = monitor["average"]["mem_percent"] if "mem_percent" in monitor["average"] else 0
+
+        # تحديد نوع الجهاز
+        device_type = task_type.upper() if task_type else "CPU"
+
+        # فحص الحمل
+        if (avg_cpu > 0.6 or avg_mem > 85 or self.devices.should_offload(device_type)):
+            logging.info(f"⚠️ الحمل مرتفع على {device_type} - إرسال المهمة للأقران")
+            self._offload_task(task_func, *args, **kwargs)
+        elif (avg_cpu <= 0.3 and self.devices.can_receive(device_type)):
+            logging.info(f"✅ الحمل منخفض على {device_type} - تنفيذ المهمة محلياً")
+            return task_func(*args, **kwargs)
+        else:
+            logging.info(f"ℹ️ الحمل متوسط على {device_type} - تنفيذ المهمة محلياً")
+            return task_func(*args, **kwargs)
+
+    def _offload_task(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("⚠️ لا توجد أجهزة متاحة - سيتم تنفيذ المهمة محلياً")
+            task_func(*args, **kwargs)
+
+    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", PORT, load=0.1)
+    print("✅ نظام توزيع المهام جاهز...")
+
+    def example_task(x):
+        return x * x
+
+    executor.submit(example_task, 5, task_type="GPU")

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,28 @@
+# dts_cli.py — أوامر CLI لتشغيل النظام الموزع
+import click
+import threading
+from peer_discovery import PEERS, PORT
+import dashboard
+import rpc_server
+
+@click.group()
+def cli():
+    pass
+
+@cli.command()
+def start():
+    """بدء Dashboard وخادم RPC معاً"""
+    # شغّل الـ Dashboard في خيط منفصل
+    t = threading.Thread(target=lambda: dashboard.socketio.run(dashboard.app, host="0.0.0.0", port=7000), daemon=True)
+    t.start()
+    # شغّل خادم RPC في الخيط الرئيسي
+    rpc_server.app.run(host="0.0.0.0", port=PORT)
+
+@cli.command()
+def discover():
+    """طباعة قائمة الأقران المكتشفة"""
+    for i, peer in enumerate(sorted(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,313 @@
+
+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
+from peer_discovery import PORT
+
+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()

external_server.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+"""
+external_server.py — سيرفر مركزي لتوزيع المهام + Dashboard تفاعلي
+"""
+import logging
+import requests
+from flask import Flask, request, jsonify, render_template
+from flask_cors import CORS
+from flask_socketio import SocketIO, emit
+from peer_discovery import PEERS
+from peer_discovery import PORT
+
+logging.basicConfig(level=logging.INFO)
+
+app = Flask(__name__)
+CORS(app, resources={r"/*": {"origins": "*"}})
+socketio = SocketIO(app, cors_allowed_origins="*")
+
+connected_peers = {}  # {node_id: {"cpu":%, "ram":%, "gpu":%}}
+
+# ─────────────── اختيار أفضل Peer ───────────────
+def select_best_peer():
+    peers_list = list(PEERS)
+    if not peers_list:
+        logging.warning("⚠️ لا توجد أجهزة مسجلة حالياً.")
+        return None
+    
+    try:
+        peer_loads = []
+        for peer_url in peers_list:
+            try:
+                resp = requests.get(f"{peer_url.replace('/run_task','')}/status", timeout=2)
+                if resp.ok:
+                    data = resp.json()
+                    peer_loads.append((peer_url, data.get("cpu_load", 100)))
+            except:
+                continue
+        
+        if not peer_loads:
+            return None
+        
+        peer_loads.sort(key=lambda x: x[1])
+        return peer_loads[0][0]
+    except Exception as e:
+        logging.error(f"❌ خطأ في اختيار الـ Peer: {e}")
+        return None
+
+# ─────────────── API توزيع المهام ───────────────
+@app.route("/submit_task", methods=["POST"])
+def submit_task():
+    data = request.get_json()
+    if not data or "task_id" not in data:
+        return jsonify({"error": "يجب تحديد task_id"}), 400
+
+    peer = select_best_peer()
+    if not peer:
+        return jsonify({"error": "لا توجد أجهزة متاحة حالياً"}), 503
+    
+    try:
+        resp = requests.post(peer, json=data, timeout=10)
+        if resp.ok:
+            return jsonify({"status": "success", "result": resp.json()})
+        else:
+            return jsonify({"error": "فشل إرسال المهمة"}), 500
+    except Exception as e:
+        logging.error(f"❌ خطأ في إرسال المهمة: {e}")
+        return jsonify({"error": str(e)}), 500
+
+# ─────────────── API تحديث حالة الأجهزة ───────────────
+@app.route("/update_status", methods=["POST"])
+def update_status():
+    data = request.json
+    node_id = data.get("node_id")
+    if not node_id:
+        return jsonify({"error": "node_id مطلوب"}), 400
+    
+    connected_peers[node_id] = {
+        "cpu": data.get("cpu"),
+        "ram": data.get("ram"),
+        "gpu": data.get("gpu")
+    }
+    socketio.emit("update_peers", connected_peers, broadcast=True)
+    return jsonify({"status": "ok"})
+
+# ─────────────── صفحة Dashboard ───────────────
+@app.route("/")
+def index():
+    return render_template("dashboard.html")
+
+# ─────────────── دردشة ───────────────
+@socketio.on("send_message")
+def handle_message(data):
+    socketio.emit("receive_message", data, broadcast=True)
+
+# ─────────────── تشغيل السيرفر ───────────────
+if __name__ == "__main__":
+    logging.info("🚀 بدء السيرفر المركزي مع Dashboard ودردشة")
+    socketio.run(app, host="0.0.0.0", port =5005)

global_memory.json

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

gui.py

@@ -0,0 +1,22 @@
+import toga
+from toga.style import Pack
+from toga.style.pack import COLUMN, CENTER
+
+class CoreFlowGUI(toga.App):
+    def startup(self):
+        label = toga.Label("مرحبًا بك في CoreFlow!", style=Pack(text_align=CENTER, font_size=18))
+        button = toga.Button("اضغطني", on_press=self.say_hello, style=Pack(padding=10))
+
+        box = toga.Box(style=Pack(direction=COLUMN, alignment=CENTER, padding=20))
+        box.add(label)
+        box.add(button)
+
+        self.main_window = toga.MainWindow(title=self.formal_name)
+        self.main_window.content = box
+        self.main_window.show()
+
+    def say_hello(self, widget):
+        self.main_window.info_dialog("تحية", "أهلاً بك يا أسامة 👋")
+
+def main():
+    return CoreFlowGUI()

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,166 @@
+
+"""
+internet_scanner.py - ماسح للبحث عن أجهزة DTS على الإنترنت
+"""
+import requests
+import threading
+import time
+import socket
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import logging
+from peer_discovery import PORT
+
+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 = PORT):
+        """مسح نطاق 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 = PORT) -> 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:PORT",
+                "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}:PORT/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,216 @@
+
+#!/usr/bin/env python3
+"""
+مشغل موحد لنظام توزيع المهام
+يوفر خيارات متعددة للتشغيل
+"""
+
+import sys
+import os
+import subprocess
+import argparse
+import time
+from pathlib import Path
+from peer_discovery import PORT
+
+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,406 @@
+
+# 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
+from peer_discovery import PORT
+
+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,78 @@
+# load_balancer.py
+import peer_discovery, requests, time, smart_tasks, psutil, socket
+from peer_discovery import PORT
+
+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,274 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+main.py — نظام توزيع المهام الذكي
+"""
+import os
+import sys
+import time
+import threading
+import subprocess
+import logging
+import argparse
+import socket
+import random
+import requests
+import importlib.util
+from pathlib import Path
+from typing import Any
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+from peer_discovery import CENTRAL_REGISTRY_SERVERS
+from peer_discovery import PORT
+# ─────────────── إعدادات المسارات ───────────────
+FILE = Path(__file__).resolve()
+BASE_DIR = FILE.parent
+sys.path.insert(0, str(BASE_DIR))
+def main():
+    print("🔧 CoreFlow يعمل الآن...")
+    # شغّل الخادم أو أي منطق أساسي هنا
+# ─────────────── إعداد السجلات ───────────────
+os.makedirs("logs", exist_ok=True)
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+    handlers=[
+        logging.StreamHandler(sys.stdout),
+        logging.FileHandler("logs/main.log", mode="a", encoding="utf-8")
+    ]
+)
+
+# ─────────────── تحميل متغيرات البيئة ───────────────
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+    logging.info("تم تحميل متغيرات البيئة من .env")
+except ImportError:
+    logging.warning("python-dotenv غير مثبَّت؛ تَخطّي .env")
+
+# ─────────────── ثوابت التهيئة ───────────────
+CPU_PORT = int(os.getenv("CPU_PORT", "5297"))
+SHARED_SECRET = os.getenv("SHARED_SECRET", "my_shared_secret_123")
+PYTHON_EXE = sys.executable
+
+# ─────────────── خيارات سطر الأوامر ───────────────
+parser = argparse.ArgumentParser(description="نظام توزيع المهام الذكي")
+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()
+
+# ─────────────── متغيرات النظام ───────────────
+PEERS = set()  # مجموعة عناوين الأقران كسلاسل نصية
+PEERS_INFO = {}  # قاموس لحفظ معلومات الأقران الكاملة
+current_server_index = 0
+
+# ─────────────── دوال اكتشاف الأقران ───────────────
+def register_service_lan():
+    """تسجيل الخدمة على الشبكة المحلية"""
+    while True:
+        try:
+            logging.info("جارٍ تسجيل الخدمة على الشبكة المحلية...")
+            time.sleep(10)
+        except Exception as e:
+            logging.error(f"خطأ في تسجيل الخدمة: {e}")
+
+def discover_lan_loop():
+    """اكتشاف الأقران على الشبكة المحلية"""
+    while True:
+        try:
+            logging.info("جارٍ مسح الشبكة المحلية...")
+            time.sleep(15)
+        except Exception as e:
+            logging.error(f"خطأ في اكتشاف الأقران: {e}")
+
+def fetch_central_loop():
+    """جلب تحديثات من السيرفر المركزي"""
+    while True:
+        try:
+            logging.info("جارٍ تحديث قائمة الأقران...")
+            time.sleep(30)
+        except Exception as e:
+            logging.error(f"خطأ في جلب التحديثات: {e}")
+
+# ─────────────── دوال مساعدة ───────────────
+def get_local_ip():
+    """الحصول على عنوان IP المحلي"""
+    try:
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        s.connect(("8.8.8.8", 80))
+        ip = s.getsockname()[0]
+        s.close()
+        return ip
+    except Exception:
+        return "127.0.0.1"
+
+def add_peer(peer_data):
+    """إضافة قرين جديد إلى النظام"""
+    peer_url = f"http://{peer_data['ip']}:{peer_data['port']}/run"
+    if peer_url not in PEERS:
+        PEERS.add(peer_url)
+        PEERS_INFO[peer_url] = peer_data
+        logging.info(f"تمت إضافة قرين جديد: {peer_url}")
+    return peer_url
+
+def benchmark(fn, *args):
+    """قياس زمن تنفيذ الدالة"""
+    t0 = time.time()
+    res = fn(*args)
+    return time.time() - t0, res
+
+def load_and_run_peer_discovery():
+    """تحميل وتشغيل ملف peer_discovery.py"""
+    try:
+        peer_discovery_path = Path(__file__).parent / "peer_discovery.py"
+        if not peer_discovery_path.exists():
+            raise FileNotFoundError("ملف peer_discovery.py غير موجود")
+        
+        spec = importlib.util.spec_from_file_location("peer_discovery_module", peer_discovery_path)
+        peer_module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(peer_module)
+        
+        logging.info("تم تحميل peer_discovery.py بنجاح")
+        return peer_module
+    except Exception as e:
+        logging.error(f"خطأ في تحميل peer_discovery.py: {str(e)}")
+        return None
+
+# ─────────────── دوال المهام ───────────────
+def example_task(x: int) -> int:
+    """دالة مثال بديلة إذا لم تكن موجودة في your_tasks.py"""
+    return x * x
+
+def matrix_multiply(size: int) -> list:
+    """ضرب المصفوفات (بديل مؤقت)"""
+    return [[i*j for j in range(size)] for i in range(size)]
+
+def prime_calculation(limit: int) -> list:
+    """حساب الأعداد الأولية (بديل مؤقت)"""
+    primes = []
+    for num in range(2, limit):
+        if all(num % i != 0 for i in range(2, int(num**0.5) + 1)):
+            primes.append(num)
+    return primes
+
+def data_processing(size: int) -> dict:
+    """معالجة البيانات (بديل مؤقت)"""
+    return {i: i**2 for i in range(size)}
+
+# ─────────────── خادم 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 connect_until_success():
+    global CPU_PORT, current_server_index
+    
+    peer_module = load_and_run_peer_discovery()
+    if peer_module is None:
+        logging.warning("سيستمر التشغيل بدون peer_discovery.py")
+        return None, []
+    
+    CENTRAL_REGISTRY_SERVERS = getattr(peer_module, 'CENTRAL_REGISTRY_SERVERS', [])
+    if not CENTRAL_REGISTRY_SERVERS:
+        logging.error("قائمة السيرفرات المركزية فارغة")
+        return None, []
+    
+    while True:
+        for port in [CPU_PORT, 5298, 5299]:
+            for idx, server in enumerate(CENTRAL_REGISTRY_SERVERS):
+                info = {
+                    "node_id": os.getenv("NODE_ID", socket.gethostname()),
+                    "ip": get_local_ip(),
+                    "port": port
+                }
+                try:
+                    resp = requests.post(f"{server}/register", json=info, timeout=5)
+                    resp.raise_for_status()
+                    CPU_PORT = port
+                    current_server_index = idx
+                    logging.info(f"تم الاتصال بالسيرفر: {server} على المنفذ {CPU_PORT}")
+                    
+                    # معالجة قائمة الأقران المستلمة
+                    peers_list = resp.json()
+                    peer_urls = []
+                    for p in peers_list:
+                        peer_url = add_peer(p)
+                        peer_urls.append(peer_url)
+                    return server, peer_urls
+                    
+                except Exception as e:
+                    logging.warning(f"فشل الاتصال بـ {server}: {str(e)}")
+        time.sleep(5)
+
+def main():
+    """الدالة الرئيسية لتشغيل النظام"""
+    # تشغيل الخدمات الأساسية
+    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}")
+
+    # الاتصال بالسيرفر الم��كزي
+    server, initial_peers = connect_until_success()
+    
+    # تشغيل خادم Flask
+    threading.Thread(target=start_flask_server, daemon=True).start()
+
+    # البقاء في حلقة رئيسية
+    try:
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        logging.info("تم إنهاء البرنامج.")
+
+if __name__ == "__main__":
+    # إضافة القرين المحلي
+    add_peer({"ip": "127.0.0.1", "port": CPU_PORT})
+    
+    # تشغيل خدمات اكتشاف الأقران
+    threading.Thread(target=register_service_lan, daemon=True).start()
+    threading.Thread(target=discover_lan_loop, daemon=True).start()
+    threading.Thread(target=fetch_central_loop, daemon=True).start()
+
+    # بدء النظام الرئيسي
+    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,
+)

node_client.py

@@ -0,0 +1,125 @@
+ #!/usr/bin/env python3
+# ================================================================
+# node_client.py – عميل تسجيل العُقدة في نظام AmalOffload
+# ---------------------------------------------------------------
+# • يختار منفذًا (من ENV أو من مجموعة PORTS).
+# • يجلب عنوان الـ IP المحلي.
+# • يحاول التسجيل في خادم سجلٍّ مركزي واحد تِلو الآخر،
+#   وعلى كل المنافذ، حتى ينجح.
+# • عند النجاح يُرجع قائمة الأقران (Peers) من الخادم.
+# ================================================================
+
+import os
+import socket
+import time
+import logging
+import random
+import requests
+from typing import Iterable, Tuple, List
+
+# ⬇️ منافذ مقترحة؛ يمكنك التعديل أو توليدها ديناميكيًا
+DEFAULT_PORTS = {
+    7520, 7384, 9021, 6998, 5810, 9274,
+    8645, 7329, 7734, 8456, 6173, 7860,
+}
+
+# ⬇️ خوادم السجل الاحتياطية بالترتيب المفضَّل
+DEFAULT_REGISTRY_SERVERS = [
+    "https://cv4790811.regru.cloud",
+    "https://amaloffload.onrender.com",
+    "https://osamabyc86-offload.hf.space",
+    "http://10.229.36.125",
+    "http://10.229.228.178",
+]
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(message)s",
+    datefmt="%H:%M:%S",
+)
+
+
+class NodeClient:
+    """
+    عميل خفيف يعتني بالتسجيل المتكرِّر في خادم سجل مركزي.
+    يمكن استيراده في أي سكربت وتشغيله في خيط منفصل.
+    """
+
+    def __init__(
+        self,
+        PORTs: Iterable[int] | None = None,
+        registry_servers: List[str] | None = None,
+        node_id: str | None = None,
+    ):
+        self.PORTs = set(PORTs) if PORTs else DEFAULT_PORTS
+        self.registry_servers = list(registry_servers) if registry_servers else DEFAULT_REGISTRY_SERVERS
+        self.node_id = node_id or os.getenv("NODE_ID", socket.gethostname())
+
+        # مبدئيًّا اختَر منفذًا (أولوية للمتغيّر البيئي إن وُجد)
+        self.port: int = int(os.getenv("CPU_PORT", random.choice(list(self.PORTs))))
+        self.current_server_index: int | None = None
+
+    # -------------------------------------------------------------------------
+    @staticmethod
+    def get_local_ip() -> str:
+        """يحاول معرفة أفضل عنوان IP محلي لاستخدامه في الشبكة."""
+        try:
+            with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
+                # لا يهم أن ينجح الاتصال الفعلي، الهدف كشف IP واجهة الخروج
+                s.connect(("10.255.255.255", 1))
+                return s.getsockname()[0]
+        except Exception:
+            return "127.0.0.1"
+
+    def _register_once(self, server: str, port: int) -> List[str]:
+        """مُحاولة واحدة للتسجيل؛ تُعيد peers أو ترفع استثناءً."""
+        payload = {
+            "node_id": self.node_id,
+            "ip": self.get_local_ip(),
+            "port": port,
+        }
+        resp = requests.post(f"{server}/register", json=payload, timeout=5)
+        resp.raise_for_status()
+        return resp.json()  # توقّع أن الخادم يُرجع قائمة أقران
+
+    # -------------------------------------------------------------------------
+    def connect_until_success(self, retry_delay: int = 5) -> Tuple[str, List[str]]:
+        """
+        يدور على جميع المنافذ والخوادم حتى ينجح التسجيل.
+        • عند النجاح يُرجع: (عنوان الخادم، قائمة الأقران)
+        • لا يرفع استثناءات؛ إمّا ينجح أو يستمر في المحاولة إلى ما لا نهاية.
+        """
+        logging.info("🔄 بدء محاولات التسجيل للعقدة '%s'...", self.node_id)
+        while True:
+            for port in self.PORTs:
+                for idx, server in enumerate(self.registry_servers):
+                    try:
+                        peers = self._register_once(server, port)
+                        # سجّل النجاح واحفظ المعلومات
+                        self.port = port
+                        self.current_server_index = idx
+                        logging.info("✅ متصل: %s على المنفذ %s", server, port)
+                        return server, peers
+                    except Exception as e:
+                        logging.debug("❌ %s:%s -> %s", server, port, e)
+            time.sleep(retry_delay)  # انتظر قليلًا ثم أعد المحاولة
+
+    # -------------------------------------------------------------------------
+    def run_background(self) -> None:
+        """
+        إطلاق التسجيل في خيط منفصل؛ مفيد إذا كنت تريد
+        إبقاء Main Thread للمهام الأخرى.
+        """
+        import threading  # استيراد متأخر لتفادي الحمل الزائد عند import
+        threading.Thread(target=self.connect_until_success, daemon=True).start()
+
+
+# -----------------------------------------------------------------------------  
+if __name__ == "__main__":
+    """
+    للتجربة المباشرة:
+    $ python node_client.py
+    """
+    client = NodeClient()
+    server, peer_list = client.connect_until_success()
+    logging.info("🗂️ الأقران: %s", peer_list)

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,97 @@
+#!/usr/bin/env python3
+import os
+import socket
+import threading
+import time
+import logging
+import requests
+from zeroconf import Zeroconf, ServiceInfo, ServiceBrowser
+
+# إعداد السجلات
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# منفذ الخدمة (بدءاً من 1000 مع زيادة متسلسلة)
+current_port = 1000
+
+def get_sequential_port():
+    global current_port
+    port = current_port
+    current_port += 1
+    if current_port > 9999:
+        current_port = 1000
+    return port
+
+PORT = "7520" and int(os.getenv("CPU_PORT", get_sequential_port()))
+SERVICE = "_tasknode._tcp.local."
+PEERS = set()
+PEERS_INFO = {}
+
+CENTRAL_REGISTRY_SERVERS = [
+    "https://cv4790811.regru.cloud",
+    "https://amaloffload.onrender.com",
+    "https://osamabyc86-offload.hf.space",
+    "https://osamabyc19866-omsd.hf.space",
+    "https://52.13.128.108",
+    "https://176.28.175.216",
+    "https://44.229.227.142"
+]
+
+def get_local_ip():
+    try:
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        s.connect(("8.8.8.8", 80))
+        ip = s.getsockname()[0]
+        s.close()
+        return ip
+    except Exception:
+        return "127.0.0.1"
+
+def register_peer(ip, port):
+    peer_url = f"http://{ip}:{port}/run"
+    if peer_url not in PEERS:
+        PEERS.add(peer_url)
+        logger.info(f"تم تسجيل قرين جديد: {peer_url}")
+
+def discover_lan_peers():
+    class Listener:
+        def add_service(self, zc, type_, name):
+            info = zc.get_service_info(type_, name)
+            if info:
+                ip = socket.inet_ntoa(info.addresses[0])
+                register_peer(ip, info.port)
+
+    zeroconf = Zeroconf()
+    ServiceBrowser(zeroconf, SERVICE, Listener())
+    return zeroconf
+
+def main():
+    logger.info("🚀 بدء نظام اكتشاف الأقران...")
+
+    # تسجيل الخدمة المحلية
+    zeroconf = Zeroconf()
+    info = ServiceInfo(
+        type_=SERVICE,
+        name=f"{socket.gethostname()}.{SERVICE}",
+        addresses=[socket.inet_aton(get_local_ip())],
+        port=int(PORT),
+        properties={b'version': b'1.0'},
+        server=f"{socket.gethostname()}.local."
+    )
+    zeroconf.register_service(info)
+
+    # بدء اكتشاف الأقران
+    discover_lan_peers()
+
+    try:
+        while True:
+            logger.info(f"عدد الأقران المكتشفين: {len(PEERS)}")
+            time.sleep(10)
+    except KeyboardInterrupt:
+        logger.info("🛑 إيقاف النظام...")
+    finally:
+        zeroconf.unregister_service(info)
+        zeroconf.close()
+
+if __name__ == "__main__":
+    main()

peer_registry.py

@@ -0,0 +1,68 @@
+import socket
+import time
+from zeroconf import Zeroconf, ServiceBrowser, ServiceInfo
+from peer_discovery import PORT
+
+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 = PORT
+
+    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,49 @@
+# peer_server.py
+
+from flask import Flask, request, jsonify  # استيراد request و jsonify مع Flask
+import psutil
+import smart_tasks
+import time
+import socket
+from peer_discovery import PORT
+from flask import Flask
+app = Flask(__name__)
+@app.route("/run", methods=["POST"])
+def run_task():
+    try:
+        data = request.get_json()
+        print("🔹 البيانات المستلمة:", data)
+        count = data.get("count", 100)
+        ...
+        return jsonify(result)
+    except Exception as e:
+        print("❌ خطأ أثناء التنفيذ:", e)
+        return jsonify({"error": str(e)}), 500
+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=PORT)
+

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:PORT/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. إعدادات الجدار الناري")

ram_manager.py

@@ -0,0 +1,162 @@
+"""
+ram_manager.py – Distributed RAM Offload Agent
+================================================
+
+❖ الغرض
+------------
+يوفِّر هذا الملف إضافة مستقلة إلى مشروع **AmalOffload** من أجل مشاركة الذاكرة (RAM) بين جميع العُقد التي تشغِّل المشروع. عندما ينخفض مقدار الذاكرة الحرة على إحدى العُقد إلى أقل من 2 جيجابايت (أو أي قيمة تحدّدها)، تُنقل كتل بيانات إلى عُقد أخرى ما تزال تملك ذاكرة حرّة.
+
+❖ المزايا الرئيسة
+------------------
+* يراقب استهلاك الذاكرة محليًّا بانتظام.
+* يعلن عن نفسه ويكتشف الأقران (Peers) تلقائيًّا بالاعتماد على `peer_registry` إن وُجد، أو على قائمة في المتغيّر البيئي `CENTRAL_PEERS` كحلّ احتياطي.
+* يعرض واجهة HTTP بسيطة (`Flask`) بثلاث مسارات:
+  * `GET  /ram_status`  → يُرجِع مقدار الذاكرة الحرّة بالعُقدة.
+  * `POST /ram_store`   → يستقبل كتلة بيانات (Base64) ويحجزها في الذاكرة.
+  * `GET  /ram_fetch/<id>` → يُرجِع كتلة بيانات مُخزّنة بحسب معرّفها.
+
+❖ طريقة التشغيل
+----------------
+```bash
+python ram_manager.py --ram-limit 2048 --chunk 64 --interval 5
+```
+أو اكتفِ بالتشغيل بدون وسائط واعتمد على القيم الافتراضيّة أو على متغيّرات البيئة:
+```bash
+export RAM_THRESHOLD_MB=2048
+export RAM_CHUNK_MB=64
+python ram_manager.py
+```
+
+❖ التعليمات البرمجيّة
+----------------------
+"""
+import os
+import psutil
+import time
+import threading
+import socket
+import base64
+import uuid
+from typing import Dict, List
+
+try:
+    from flask import Flask, request, jsonify
+except ImportError as exc:
+    raise RuntimeError("Flask غير مُثبّت. نفِّذ: pip install flask") from exc
+
+# محاولة استيراد مُسجِّل الأقران الحالي من المشروع
+try:
+    import peer_registry  # يتوقع أن يحتوي على list_peers()
+except ImportError:
+    peer_registry = None
+
+# الإعدادات – قابلة للتعديل عبر متغيّرات البيئة
+RAM_LIMIT_MB    = int(os.getenv("RAM_THRESHOLD_MB", "2048"))  # الحد الأدنى للرام الحرّة قبل الت offload
+CHUNK_MB        = int(os.getenv("RAM_CHUNK_MB", "64"))       # حجم الكتلة المُرسَلة
+CHECK_INTERVAL  = int(os.getenv("RAM_CHECK_INTERVAL", "5"))  # ثواني بين كل فحص
+RAM_PORT        = int(os.getenv("RAM_PORT", "8765"))          # بورت واجهة الذاكرة
+
+app = Flask(__name__)
+
+# مخزن الكتل الواردة
+remote_chunks: Dict[str, bytes] = {}
+
+def get_free_ram_mb() -> int:
+    """الذاكرة الحرّة بالميغابايت"""
+    return psutil.virtual_memory().available // (1024 * 1024)
+
+# ─────────────────── واجهة HTTP ────────────────────
+@app.route("/ram_status", methods=["GET"])
+def ram_status():
+    """إرجاع كميّة الذاكرة الحرّة بالعُقدة."""
+    return jsonify({"free_mb": get_free_ram_mb()})
+
+@app.route("/ram_store", methods=["POST"])
+def ram_store():
+    """تلقّي كتلة بيانات وتخزينها."""
+    payload = request.get_json(force=True)
+    cid     = payload["id"]
+    blob_b64= payload["data"]
+    remote_chunks[cid] = base64.b64decode(blob_b64)
+    return jsonify({"status": "stored", "id": cid})
+
+@app.route("/ram_fetch/<cid>", methods=["GET"])
+def ram_fetch(cid):
+    blob = remote_chunks.get(cid)
+    if blob is None:
+        return jsonify({"error": "not found"}), 404
+    return jsonify({"id": cid, "data": base64.b64encode(blob).decode()})
+
+# ─────────────────── وظائف داخليّة ───────────────────
+
+def start_api():
+    """تشغيل خادم Flask في خيط منفصل."""
+    from werkzeug.serving import make_server
+    server = make_server("0.0.0.0", RAM_PORT, app)
+    server.serve_forever()
+
+
+def discover_peers() -> List[str]:
+    """الحصول على قائمة IPs للأقران، باستثناء عنوان الجهاز الحالي."""
+    peers: List[str] = []
+
+    if peer_registry and hasattr(peer_registry, "list_peers"):
+        try:
+            peers_info = peer_registry.list_peers()  # متوقع: [{"ip": "..."}, ...]
+            peers = [p["ip"] for p in peers_info if p.get("ip")]
+        except Exception:
+            pass
+    else:
+        central_env = os.getenv("CENTRAL_PEERS", "")
+        if central_env:
+            peers = central_env.split(",")
+
+    # إزالة عنوان الجهاز المحلي
+    try:
+        local_ip = socket.gethostbyname(socket.gethostname())
+        peers = [ip for ip in peers if ip != local_ip]
+    except Exception:
+        pass
+
+    return peers
+
+
+def offload_chunk(blob: bytes, peer_ip: str) -> bool:
+    """إرسال كتلة بيانات إلى peer محدّد."""
+    import requests
+    try:
+        resp = requests.post(
+            f"http://{peer_ip}:{RAM_PORT}/ram_store",
+            json={"id": str(uuid.uuid4()), "data": base64.b64encode(blob).decode()},
+            timeout=5,
+        )
+        return resp.status_code == 200
+    except Exception:
+        return False
+
+
+def monitor_loop():
+    """مراقبة الذاكرة واستدعاء offload عند الحاجة."""
+    while True:
+        free_mb = get_free_ram_mb()
+        if free_mb < RAM_LIMIT_MB:
+            peers = discover_peers()
+            if not peers:
+                print("[RAM] لا يوجد أقران متاحون حاليًا.")
+            else:
+                blob = bytes(CHUNK_MB * 1024 * 1024)  # كتلة وهميّة – استبدلها ببيانات حقيقيّة عند الدمج
+                for ip in peers:
+                    if offload_chunk(blob, ip):
+                        print(f"[RAM]‎ أرسلت ‎{CHUNK_MB}‎MB إلى ‎{ip}")
+                        break
+                else:
+                    print("[RAM] كل الأقران رفضوا التخزين أو حدث خطأ.")
+        time.sleep(CHECK_INTERVAL)
+
+
+def main():
+    threading.Thread(target=start_api, daemon=True).start()
+    monitor_loop()
+
+if __name__ == "__main__":
+    main()

remote_executor.py

@@ -0,0 +1,105 @@
+# 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
+from peer_discovery import PORT
+
+# عنوان افتراضي احتياطي (يمكن تغييره بمتغير بيئي REMOTE_SERVER)
+FALLBACK_SERVER = os.getenv(
+    "REMOTE_SERVER",
+    "http://89.111.171.92:PORT/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

@@ -1 +1,24 @@
-huggingface_hub==0.25.2
+Flask
+flask_cors
+requests
+psutil
+zeroconf
+cryptography
+numpy
+networkx
+Flask
+flask_cors
+requests
+psutil
+zeroconf
+cryptography
+numpy
+networkx
+flask
+GPUtil
+requests
+python-dotenv
+torch
+flask_socketio
+
+

rpc_server.py

@@ -0,0 +1,74 @@
+# 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
+from peer_discovery import PORT
+
+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":
+    # تأكد أن المنفذ PORT مفتوح
+    app.run(host="0.0.0.0", port=PORT)

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,121 @@
+# 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
+from peer_discovery import PORT
+
+
+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()))
+