Upload 69 files

background_service.py

@@ -239,8 +239,8 @@ class BackgroundService:
         self.setup_signal_handlers()
         
         # تشغيل خادم HTTP API للتحكم
-        self.logger.info("🌐 تشغيل HTTP API على المنفذ 8888")
-        self.app.run(host='0.0.0.0', port=8888, debug=False)
+        self.logger.info("🌐 تشغيل HTTP API على المنفذ51738")
+        self.app.run(host='0.0.0.0', port=5173, debug=False)
 
 def main():
     service = BackgroundService()
@@ -254,7 +254,7 @@ def main():
             # فحص حالة الخدمة
             import requests
             try:
-                response = requests.get('http://localhost:8888/status')
+                response = requests.get('http://localhost:5173/status')
                 print(json.dumps(response.json(), indent=2, ensure_ascii=False))
             except:
                 print("❌ الخدمة غير متاحة")
@@ -262,7 +262,7 @@ def main():
             # إيقاف الخدمة
             import requests
             try:
-                response = requests.post('http://localhost:8888/stop')
+                response = requests.post('http://localhost:5173/stop')
                 print(response.json()['message'])
             except:
                 print("❌ فشل في إيقاف الخدمة")
@@ -270,7 +270,7 @@ def main():
             # إظهار الواجهة التفاعلية
             import requests
             try:
-                response = requests.post('http://localhost:8888/show-ui')
+                response = requests.post('http://localhost:5173/show-ui')
                 print(response.json()['message'])
             except:
                 print("❌ فشل في إظهار الواجهة التفاعلية")

dashboard.py

@@ -34,7 +34,7 @@ def get_system_status():
 def broadcast_status():
     while True:
         status = get_system_status()
-        socketio.emit("status_update", {node_id: status}, broadcast=True)
+        socketio.emit("status_update", {node_id: status})  # تم إزالة broadcast=True
         socketio.sleep(5)
 
 # ─────────────── صفحة الواجهة ───────────────
@@ -46,7 +46,7 @@ def index():
 @socketio.on("status_update")
 def handle_status_update(data):
     connected_peers_data.update(data)
-    emit("update_peers", connected_peers_data, broadcast=True)
+    emit("update_peers", connected_peers_data, broadcast=True)  # هذا صحيح لأنه داخل معالج حدث
 
 # ─────────────── دردشة ───────────────
 @socketio.on("send_message")
@@ -55,6 +55,6 @@ def handle_message(data):
 
 # ─────────────── تشغيل ───────────────
 if __name__ == "__main__":
-    threading.Thread(target=broadcast_status).start()
+    threading.Thread(target=broadcast_status, daemon=True).start()  # أضفت daemon=True
     logging.info(f"🚀 تشغيل Dashboard على {node_id}")
     socketio.run(app, host="0.0.0.0", port=7000)

external_server.py

@@ -4,6 +4,7 @@ external_server.py — سيرفر مركزي لتوزيع المهام + Dashboa
 """
 import logging
 import requests
+import socket
 from flask import Flask, request, jsonify, render_template
 from flask_cors import CORS
 from flask_socketio import SocketIO, emit
@@ -18,29 +19,49 @@ socketio = SocketIO(app, cors_allowed_origins="*")
 
 connected_peers = {}  # {node_id: {"cpu":%, "ram":%, "gpu":%}}
 
+# ─────────────── التحقق من توفر المنفذ ───────────────
+def is_port_available(port):
+    try:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.bind(('0.0.0.0', port))
+            return True
+    except OSError:
+        return False
+
 # ─────────────── اختيار أفضل Peer ───────────────
 def select_best_peer():
-    peers_list = list(PEERS)
-    if not peers_list:
+    if not PEERS:
         logging.warning("⚠️ لا توجد أجهزة مسجلة حالياً.")
         return None
     
     try:
         peer_loads = []
-        for peer_url in peers_list:
+        for peer_url in PEERS:
             try:
-                resp = requests.get(f"{peer_url.replace('/run_task','')}/status", timeout=2)
+                # بناء URL لفحص الحالة
+                status_url = peer_url.replace('/run_task', '/health')
+                if '/run_task' not in peer_url:
+                    status_url = f"{peer_url}/health"
+                
+                resp = requests.get(status_url, timeout=2)
                 if resp.ok:
                     data = resp.json()
-                    peer_loads.append((peer_url, data.get("cpu_load", 100)))
-            except:
+                    # افتراض أن الخادم يعيد cpu_load أو استخدام قيمة افتراضية
+                    cpu_load = data.get("cpu_load", 50)
+                    peer_loads.append((peer_url, cpu_load))
+                    logging.info(f"✅ {peer_url} - الحمل: {cpu_load}%")
+            except Exception as e:
+                logging.warning(f"❌ لا يمكن الوصول إلى {peer_url}: {e}")
                 continue
         
         if not peer_loads:
             return None
         
-        peer_loads.sort(key=lambda x: x[1])
-        return peer_loads[0][0]
+        # اختيار الأقل حملًا
+        best_peer = min(peer_loads, key=lambda x: x[1])
+        logging.info(f"🎯 أفضل جهاز: {best_peer[0]} مع حمل {best_peer[1]}%")
+        return best_peer[0]
+        
     except Exception as e:
         logging.error(f"❌ خطأ في اختيار الـ Peer: {e}")
         return None
@@ -49,21 +70,34 @@ def select_best_peer():
 @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
+    if not data or "func" not in data:
+        return jsonify({"error": "يجب تحديد اسم الدالة (func)"}), 400
 
     peer = select_best_peer()
     if not peer:
         return jsonify({"error": "لا توجد أجهزة متاحة حالياً"}), 503
     
     try:
-        resp = requests.post(peer, json=data, timeout=10)
+        # تأكد من أن عنوان الـ Peer صحيح
+        if not peer.startswith('http'):
+            peer = f"http://{peer}"
+        
+        logging.info(f"📤 إرسال المهمة إلى: {peer}")
+        resp = requests.post(peer, json=data, timeout=30)
+        
         if resp.ok:
-            return jsonify({"status": "success", "result": resp.json()})
+            result = resp.json()
+            logging.info(f"✅ تم تنفيذ المهمة بنجاح على {peer}")
+            return jsonify({"status": "success", "result": result, "executed_on": peer})
         else:
-            return jsonify({"error": "فشل إرسال المهمة"}), 500
+            logging.error(f"❌ فشل تنفيذ المهمة على {peer}: {resp.status_code}")
+            return jsonify({"error": f"فشل إرسال المهمة: {resp.text}"}), 500
+            
+    except requests.exceptions.Timeout:
+        logging.error(f"⏰ انتهت المهلة أثناء الاتصال بـ {peer}")
+        return jsonify({"error": "انتهت مهلة الاتصال"}), 408
     except Exception as e:
-        logging.error(f"❌ خطأ في إرسال المهمة: {e}")
+        logging.error(f"❌ خطأ في إرسال المهمة إلى {peer}: {e}")
         return jsonify({"error": str(e)}), 500
 
 # ─────────────── API تحديث حالة الأجهزة ───────────────
@@ -75,24 +109,63 @@ def update_status():
         return jsonify({"error": "node_id مطلوب"}), 400
     
     connected_peers[node_id] = {
-        "cpu": data.get("cpu"),
-        "ram": data.get("ram"),
-        "gpu": data.get("gpu")
+        "cpu": data.get("cpu", 0),
+        "ram": data.get("ram", 0),
+        "gpu": data.get("gpu", 0),
+        "last_update": "now"  # يمكن إضافة timestamp
     }
+    
     socketio.emit("update_peers", connected_peers, broadcast=True)
+    logging.info(f"📊 تم تحديث حالة {node_id}")
     return jsonify({"status": "ok"})
 
+# ─────────────── صفحة الحالة ───────────────
+@app.route("/status")
+def status():
+    return jsonify({
+        "connected_peers": connected_peers,
+        "available_peers": list(PEERS),
+        "total_peers": len(PEERS)
+    })
+
 # ─────────────── صفحة Dashboard ───────────────
 @app.route("/")
 def index():
-    return render_template("dashboard.html")
+    return render_template("dashboard.html", peers=connected_peers)
+
+# ─────────────── استقبال تحديثات الحالة عبر WebSocket ───────────────
+@socketio.on("status_update")
+def handle_status_update(data):
+    connected_peers.update(data)
+    emit("update_peers", connected_peers, broadcast=True)
 
 # ─────────────── دردشة ───────────────
 @socketio.on("send_message")
 def handle_message(data):
-    socketio.emit("receive_message", data, broadcast=True)
+    emit("receive_message", data, broadcast=True)
 
 # ─────────────── تشغيل السيرفر ───────────────
 if __name__ == "__main__":
-    logging.info("🚀 بدء السيرفر المركزي مع Dashboard ودردشة")
-    socketio.run(app, host="0.0.0.0", port = PORT)
+    # محاولة منافذ مختلفة
+    ports_to_try = [5005, 5006, 5007, 5008, 5009]
+    selected_port = None
+    
+    for port in ports_to_try:
+        if is_port_available(port):
+            selected_port = port
+            break
+    
+    if selected_port is None:
+        logging.error("❌ لا توجد منافذ متاحة. حاول إغلاق التطبيقات الأخرى.")
+        exit(1)
+    
+    logging.info(f"🚀 بدء السيرفر المركزي مع Dashboard على المنفذ {selected_port}")
+    
+    try:
+        socketio.run(app, host="0.0.0.0", port=selected_port, debug=False)
+    except OSError as e:
+        logging.error(f"❌ فشل تشغيل السيرفر على المنفذ {selected_port}: {e}")
+    except KeyboardInterrupt:
+        logging.info("⏹️ إيقاف السيرفر...")
+    except Exception as e:
+        logging.error(f"❌ خطأ غير متوقع: {e}")

history.json

@@ -19,6 +19,14 @@
     "role": "user",
     "content": "مم"
   },
+  {
+    "role": "assistant",
+    "content": "عذراً، حدث خطأ: 401"
+  },
+  {
+    "role": "user",
+    "content": "hi"
+  },
   {
     "role": "assistant",
     "content": "عذراً، حدث خطأ: 401"

live_streaming.py

@@ -1,4 +1,3 @@
-
 # live_streaming.py - نظام البث المباشر للألعاب والفيديو
 
 import cv2
@@ -61,13 +60,35 @@ def stream_offload(func):
 def estimate_stream_complexity(func, args, kwargs):
     """تقدير تعقيد معالجة البث"""
     if func.__name__ == "process_game_stream":
-        return args[1] * args[2] / 10000  # FPS × الدقة
+        # استخراج القيم الرقمية من الدقة
+        resolution = args[2] if len(args) > 2 else "1920x1080"
+        if isinstance(resolution, str) and 'x' in resolution:
+            try:
+                width, height = map(int, resolution.split('x'))
+                resolution_factor = width * height / 10000
+            except:
+                resolution_factor = 1920 * 1080 / 10000  # قيمة افتراضية
+        else:
+            resolution_factor = 1920 * 1080 / 10000
+            
+        fps = args[1] if len(args) > 1 else 60
+        return fps * resolution_factor
+        
     elif func.__name__ == "real_time_video_enhancement":
-        return args[0] * 20  # عدد التحسينات × 20
+        enhancements = args[0] if len(args) > 0 else []
+        return len(enhancements) * 20  # عدد التحسينات × 20
+        
     elif func.__name__ == "multi_stream_processing":
-        return len(args[0]) * 25  # عدد البثوث × 25
+        streams = args[0] if len(args) > 0 else []
+        return len(streams) * 25  # عدد البثوث × 25
+        
     elif func.__name__ == "ai_commentary_generation":
-        return args[1] * 15  # طول النص × 15
+        commentary_length = args[1] if len(args) > 1 else 50
+        return commentary_length * 15  # طول النص × 15
+        
+    elif func.__name__ == "stream_quality_optimization":
+        return 40  # تعقيد متوسط
+        
     return 40
 
 # ═══════════════════════════════════════════════════════════════
@@ -75,7 +96,7 @@ def estimate_stream_complexity(func, args, kwargs):
 # ═══════════════════════════════════════════════════════════════
 
 @stream_offload
-def process_game_stream(stream_data, fps, resolution, enhancements=None):
+def process_game_stream(stream_data, fps=60, resolution="1920x1080", enhancements=None):
     """معالجة بث الألعاب في الوقت الفعلي"""
     start_time = time.time()
     
@@ -221,7 +242,7 @@ def multi_stream_processing(streams_data, processing_mode="parallel"):
 # ═══════════════════════════════════════════════════════════════
 
 @stream_offload
-def ai_commentary_generation(game_events, commentary_length, language="ar"):
+def ai_commentary_generation(game_events, commentary_length=50, language="ar"):
     """توليد تعليق ذكي للألعاب"""
     start_time = time.time()
     

load_balancer.py

@@ -1,78 +1,278 @@
 # load_balancer.py
-import peer_discovery, requests, time, smart_tasks, psutil, socket
+import peer_discovery
+import requests
+import time
+import smart_tasks
+import psutil
+import socket
+import threading
+import logging
+from datetime import datetime
 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)}
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
-def choose_peer():
-    """اختيار أفضل جهاز - أولوية LAN ثم WAN"""
-    import socket
+class SmartLoadBalancer:
+    def __init__(self):
+        self.peer_stats = {}
+        self.local_hostname = socket.gethostname()
+        self.local_ip = self.get_local_ip()
+        self.running = True
+        
+    def get_local_ip(self):
+        """الحصول على 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:
+            return "127.0.0.1"
     
-    lan_peers = []
-    wan_peers = []
+    def send(self, peer, func, *args, **kwargs):
+        """إرسال مهمة إلى نظير"""
+        try:
+            url = f"{peer}/run" if not peer.endswith("/run") else peer
+            payload = {
+                "func": func,
+                "args": list(args),
+                "kwargs": kwargs
+            }
+            
+            logging.info(f"📤 إرسال مهمة {func} إلى {peer}")
+            response = requests.post(url, json=payload, timeout=15)
+            
+            if response.status_code == 200:
+                result = response.json()
+                logging.info(f"✅ تم استلام النتيجة من {peer}")
+                return result
+            else:
+                logging.error(f"❌ خطأ من {peer}: {response.status_code}")
+                return {"error": f"HTTP {response.status_code}"}
+                
+        except requests.exceptions.Timeout:
+            logging.error(f"⏰ انتهت المهلة مع {peer}")
+            return {"error": "Request timeout"}
+        except requests.exceptions.ConnectionError:
+            logging.error(f"🔌 تعذر الاتصال بـ {peer}")
+            return {"error": "Connection failed"}
+        except Exception as e:
+            logging.error(f"❌ خطأ غير متوقع مع {peer}: {str(e)}")
+            return {"error": str(e)}
     
-    # تصنيف الأجهزة
-    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)
+    def choose_peer(self):
+        """اختيار أفضل جهاز مع خوارزمية متطورة"""
+        available_peers = self.get_available_peers()
+        
+        if not available_peers:
+            logging.info("🔍 لم يتم العثور على أقران متاحة")
+            return None
+        
+        # تقييم كل نظير
+        peer_scores = []
+        for peer in available_peers:
+            score = self.evaluate_peer(peer)
+            if score > 0:
+                peer_scores.append((peer, score))
+        
+        if not peer_scores:
+            return None
+            
+        # اختيار النظير بأعلى درجة
+        best_peer = max(peer_scores, key=lambda x: x[1])[0]
+        logging.info(f"🏆 أفضل نظير مختار: {best_peer}")
+        return best_peer
     
-    # أولاً: جرب الأجهزة المحلية (LAN)
-    best_lan = find_best_peer(lan_peers)
-    if best_lan:
-        return best_lan
+    def get_available_peers(self):
+        """الحصول على قائمة الأقران المتاحة"""
+        peers = []
+        
+        # اكتشاف الأقران المحليين
+        local_peers = self.discover_local_peers()
+        peers.extend(local_peers)
+        
+        # إضافة الأقران من peer_discovery
+        for peer in list(peer_discovery.PEERS):
+            if peer not in peers:
+                peers.append(peer)
+        
+        # إزالة التكرارات والنظير المحلي
+        unique_peers = []
+        for peer in peers:
+            if self.is_self_peer(peer):
+                continue
+            if peer not in unique_peers:
+                unique_peers.append(peer)
+        
+        logging.info(f"👥 الأقران المتاحون: {len(unique_peers)}")
+        return unique_peers
     
-    # ثانياً: إذا لم تتوفر أجهزة محلية، جرب WAN
-    if internet_available():
-        best_wan = find_best_peer(wan_peers)
-        return best_wan
+    def discover_local_peers(self):
+        """اكتشاف الأقران على الشبكة المحلية"""
+        local_peers = []
+        base_ip = ".".join(self.local_ip.split(".")[:-1])  # الحصول على 192.168.1
+        
+        # فحص نطاق IPs المحلي
+        for i in range(1, 255):
+            if i == int(self.local_ip.split(".")[-1]):
+                continue  # تخطي الذات
+            
+            ip = f"{base_ip}.{i}"
+            peer_url = f"http://{ip}:{PORT}"
+            
+            # فحص سريع للتوصيل
+            if self.check_peer_availability(peer_url):
+                local_peers.append(peer_url)
+        
+        return local_peers
     
-    return None
-
-def find_best_peer(peers):
-    """العثور على أفضل جهاز من قائمة معينة"""
-    best = None
-    for p in peers:
+    def check_peer_availability(self, peer_url):
+        """فحص توفر النظير"""
+        try:
+            response = requests.get(f"{peer_url}/status", timeout=2)
+            return response.status_code == 200
+        except:
+            return False
+    
+    def is_self_peer(self, peer_url):
+        """فحص إذا كان النظير هو الجهاز الحالي"""
+        if f"://{self.local_ip}:" in peer_url:
+            return True
+        if f"://localhost:" in peer_url:
+            return True
+        if f"://127.0.0.1:" in peer_url:
+            return True
+        return False
+    
+    def evaluate_peer(self, peer):
+        """تقييم أداء النظير"""
         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
+            # الحصول على حالة النظام
+            status_url = peer.replace("/run", "/status") if "/run" in peer else f"{peer}/status"
+            response = requests.get(status_url, timeout=3)
+            
+            if response.status_code == 200:
+                status = response.json()
+                
+                # حساب الدرجة
+                score = 100
+                
+                # خصم حسب استخدام CPU
+                cpu_usage = status.get("cpu_usage", 50)
+                score -= cpu_usage * 0.5
+                
+                # خصم حسب استخدام الذاكرة
+                memory_usage = status.get("memory_usage", 50)
+                score -= memory_usage * 0.3
+                
+                # مكافأة للاتصالات المحلية
+                if self.is_local_peer(peer):
+                    score += 20
+                
+                # خصم للاتصال البطيء
+                response_time = response.elapsed.total_seconds()
+                score -= response_time * 10
+                
+                return max(0, score)
+            
+        except Exception as e:
+            logging.debug(f"تعذر تقييم {peer}: {str(e)}")
+        
+        return 0
+    
+    def is_local_peer(self, peer):
+        """فحص إذا كان النظير محلي"""
+        peer_ip = peer.split("://")[1].split(":")[0] if "://" in peer else peer.split(":")[0]
+        return self.is_local_ip(peer_ip)
+    
+    def is_local_ip(self, ip):
+        """فحص إذا كان IP محلي"""
+        return (
+            ip.startswith('192.168.') or 
+            ip.startswith('10.') or 
+            ip.startswith('172.') or
+            ip in ['127.0.0.1', 'localhost', self.local_ip]
+        )
+    
+    def execute_task(self, func_name, *args, **kwargs):
+        """تنفيذ المهمة إما محلياً أو عن بعد"""
+        peer = self.choose_peer()
+        
+        if peer:
+            logging.info(f"🛰️ إرسال مهمة {func_name} إلى {peer}")
+            result = self.send(peer, func_name, *args, **kwargs)
+            
+            if "error" not in result:
+                return result
+            else:
+                logging.warning(f"❌ فشل الإرسال إلى {peer}: {result['error']}")
+        
+        # التنفيذ المحلي كبديل
+        logging.info(f"⚙️ تنفيذ محلي للمهمة {func_name}")
+        return self.execute_locally(func_name, *args, **kwargs)
+    
+    def execute_locally(self, func_name, *args, **kwargs):
+        """تنفيذ المهمة محلياً"""
+        try:
+            if hasattr(smart_tasks, func_name):
+                func = getattr(smart_tasks, func_name)
+                result = func(*args, **kwargs)
+                return result
+            else:
+                return {"error": f"الدالة {func_name} غير موجودة"}
+        except Exception as e:
+            return {"error": str(e)}
+    
+    def start_monitoring(self):
+        """بدء مراقبة الأقران"""
+        def monitor_loop():
+            while self.running:
+                try:
+                    available_peers = self.get_available_peers()
+                    logging.info(f"📊 المراقبة: {len(available_peers)} أقران متاحون")
+                    time.sleep(30)
+                except Exception as e:
+                    logging.error(f"خطأ في المراقبة: {e}")
+                    time.sleep(60)
+        
+        monitor_thread = threading.Thread(target=monitor_loop, daemon=True)
+        monitor_thread.start()
+    
+    def stop(self):
+        """إيقاف موازن الحمل"""
+        self.running = False
 
-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'
-    )
+# إنشاء نسخة عالمية
+load_balancer = SmartLoadBalancer()
 
-def internet_available():
-    """فحص توفر الإنترنت"""
+def send_task(func_name, *args, **kwargs):
+    """وظيفة مساعدة لإرسال المهام"""
+    return load_balancer.execute_task(func_name, *args, **kwargs)
+
+# التشغيل الرئيسي
+def main():
+    logging.info("🚀 بدء تشغيل موازن الحمل الذكي")
+    
+    # بدء المراقبة
+    load_balancer.start_monitoring()
+    
     try:
-        socket.create_connection(("8.8.8.8", 53), timeout=3)
-        return True
-    except:
-        return False
+        while load_balancer.running:
+            # تنفيذ مهام اختبارية
+            result = load_balancer.execute_task("prime_calculation", 20000)
+            
+            if "error" in result:
+                logging.error(f"❌ خطأ في التنفيذ: {result['error']}")
+            else:
+                primes_count = result.get('count', 0)
+                logging.info(f"✅ تم تنفيذ المهمة - عدد الأعداد الأولية: {primes_count}")
+            
+            time.sleep(15)
+            
+    except KeyboardInterrupt:
+        logging.info("🛑 إيقاف موازن الحمل...")
+        load_balancer.stop()
 
-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)
+if __name__ == "__main__":
+    main()

main.py

@@ -20,6 +20,7 @@ from flask import Flask, request, jsonify
 from flask_cors import CORS
 from peer_discovery import CENTRAL_REGISTRY_SERVERS
 from peer_discovery import PORT
+import external_server
 # ─────────────── إعدادات المسارات ───────────────
 FILE = Path(__file__).resolve()
 BASE_DIR = FILE.parent
@@ -38,30 +39,6 @@ logging.basicConfig(
     ]
 )
 
-import multiprocessing
-import time
-import sys
-import os
-
-# دالة تشغيل السيرفر الخارجي
-def run_external_server():
-    """تشغيل ملف exexternal_server.py في عملية منفصلة"""
-    try:
-        # استيراد وتشغيل الملف
-        import exexternal_server
-        exexternal_server.main()  # افترض أن الدالة الرئيسية اسمها main
-    except Exception as e:
-        print(f"خطأ في تشغيل السيرفر: {e}")
-
-# في الملف الرئيسي
-def start_external_server_process():
-    """تشغيل السيرفر في عملية منفصلة"""
-    process = multiprocessing.Process(target=run_external_server)
-    process.daemon = True  # سيتوقف تلقائياً عند إنهاء البرنامج الرئيسي
-    process.start()
-    print(f"تم تشغيل السيرفر الخارجي (PID: {process.pid})")
-    return process
-
 # ─────────────── تحميل متغيرات البيئة ───────────────
 try:
     from dotenv import load_dotenv

main.spec

@@ -1,38 +1,44 @@
-# -*- 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,
-)
+# -*- mode: python ; coding: utf-8 -*-
+
+
+block_cipher = None
+
+
+a = Analysis(
+    ['main.py'],
+    pathex=[],
+    binaries=[],
+    datas=[('*', '.')],
+    hiddenimports=[],
+    hookspath=[],
+    hooksconfig={},
+    runtime_hooks=[],
+    excludes=[],
+    win_no_prefer_redirects=False,
+    win_private_assemblies=False,
+    cipher=block_cipher,
+    noarchive=False,
+)
+pyz = PYZ(a.pure, a.zipped_data, cipher=block_cipher)
+
+exe = EXE(
+    pyz,
+    a.scripts,
+    a.binaries,
+    a.zipfiles,
+    a.datas,
+    [],
+    name='main',
+    debug=False,
+    bootloader_ignore_signals=False,
+    strip=False,
+    upx=True,
+    upx_exclude=[],
+    runtime_tmpdir=None,
+    console=True,
+    disable_windowed_traceback=False,
+    argv_emulation=False,
+    target_arch=None,
+    codesign_identity=None,
+    entitlements_file=None,
+)

node_client.py

@@ -1,4 +1,4 @@
- #!/usr/bin/env python3
+#!/usr/bin/env python3
 # ================================================================
 # node_client.py – عميل تسجيل العُقدة في نظام AmalOffload
 # ---------------------------------------------------------------
@@ -21,15 +21,20 @@ from typing import Iterable, Tuple, List
 DEFAULT_PORTS = {
     7520, 7384, 9021, 6998, 5810, 9274,
     8645, 7329, 7734, 8456, 6173, 7860,
+    8080, 8000, 5000, 3000, 8888, 9999
 }
 
 # ⬇️ خوادم السجل الاحتياطية بالترتيب المفضَّل
 DEFAULT_REGISTRY_SERVERS = [
+    "http://localhost:8888",  # خادم محلي أولاً
+    "http://127.0.0.1:8888",  # خادم محلي بديل
     "https://cv4790811.regru.cloud",
     "https://amaloffload.onrender.com",
     "https://osamabyc86-offload.hf.space",
     "http://10.229.36.125",
     "http://10.229.228.178",
+    "http://192.168.1.1:8888",  # راوتر محلي
+    "http://192.168.0.1:8888",  # راوتر محلي بديل
 ]
 
 logging.basicConfig(
@@ -56,8 +61,10 @@ class NodeClient:
         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.port: int = int(os.getenv("CPU_PORT", random.choice(list(self.PORTs))))  # 🔧 تصحيح: PORTs بدلاً من PORTS
         self.current_server_index: int | None = None
+        self.session = requests.Session()
+        self.session.timeout = 10
 
     # -------------------------------------------------------------------------
     @staticmethod
@@ -66,10 +73,15 @@ class NodeClient:
         try:
             with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
                 # لا يهم أن ينجح الاتصال الفعلي، الهدف كشف IP واجهة الخروج
-                s.connect(("10.255.255.255", 1))
+                s.connect(("8.8.8.8", 53))
                 return s.getsockname()[0]
         except Exception:
-            return "127.0.0.1"
+            try:
+                # محاولة بديلة
+                hostname = socket.gethostname()
+                return socket.gethostbyname(hostname)
+            except Exception:
+                return "127.0.0.1"
 
     def _register_once(self, server: str, port: int) -> List[str]:
         """مُحاولة واحدة للتسجيل؛ تُعيد peers أو ترفع استثناءً."""
@@ -77,32 +89,106 @@ class NodeClient:
             "node_id": self.node_id,
             "ip": self.get_local_ip(),
             "port": port,
+            "hostname": socket.gethostname(),
+            "timestamp": time.time()
         }
-        resp = requests.post(f"{server}/register", json=payload, timeout=5)
-        resp.raise_for_status()
-        return resp.json()  # توقّع أن الخادم يُرجع قائمة أقران
+        
+        # جرب مسارات مختلفة للتسجيل
+        endpoints = ["/register", "/api/register", "/nodes/register", "/peer/register"]
+        
+        for endpoint in endpoints:
+            try:
+                url = f"{server.rstrip('/')}{endpoint}"
+                logging.info(f"🔗 محاولة التسجيل في: {url}")
+                resp = self.session.post(url, json=payload, timeout=8)
+                
+                if resp.status_code == 200:
+                    data = resp.json()
+                    logging.info(f"✅ تسجيل ناجح في {server}")
+                    return data.get("peers", []) if isinstance(data, dict) else data
+                elif resp.status_code == 404:
+                    continue  # جرب endpoint التالي
+                else:
+                    resp.raise_for_status()
+                    
+            except requests.exceptions.Timeout:
+                logging.warning(f"⏰ انتهت المهلة مع {server}{endpoint}")
+                continue
+            except requests.exceptions.ConnectionError:
+                logging.warning(f"🔌 تعذر الاتصال بـ {server}{endpoint}")
+                continue
+            except Exception as e:
+                logging.warning(f"❌ خطأ مع {server}{endpoint}: {e}")
+                continue
+        
+        # إذا وصلنا هنا، فكل المحاولات فشلت
+        raise Exception(f"فشل التسجيل في {server} بعد تجربة جميع المسارات")
 
     # -------------------------------------------------------------------------
-    def connect_until_success(self, retry_delay: int = 5) -> Tuple[str, List[str]]:
+    def discover_local_servers(self) -> List[str]:
+        """اكتشاف خوادم محلية على الشبكة."""
+        local_servers = []
+        base_ip = ".".join(self.get_local_ip().split(".")[:-1])
+        
+        # فحص نطاق IPs المحلي
+        for i in range(1, 50):  # فحص أول 50 عنوان فقط للسرعة
+            if i == int(self.get_local_ip().split(".")[-1]):
+                continue  # تخطي الذات
+            
+            ip = f"{base_ip}.{i}"
+            for port in [8888, 8000, 5000, 3000]:
+                server_url = f"http://{ip}:{port}"
+                if self.check_server_availability(server_url):
+                    local_servers.append(server_url)
+                    logging.info(f"🔍 تم اكتشاف خادم محلي: {server_url}")
+        
+        return local_servers
+
+    def check_server_availability(self, server_url: str) -> bool:
+        """فحص توفر الخادم."""
+        try:
+            resp = self.session.get(f"{server_url}/status", timeout=2)
+            return resp.status_code == 200
+        except:
+            return False
+
+    def connect_until_success(self, retry_delay: int = 10) -> Tuple[str, List[str]]:
         """
         يدور على جميع المنافذ والخوادم حتى ينجح التسجيل.
         • عند النجاح يُرجع: (عنوان الخادم، قائمة الأقران)
         • لا يرفع استثناءات؛ إمّا ينجح أو يستمر في المحاولة إلى ما لا نهاية.
         """
         logging.info("🔄 بدء محاولات التسجيل للعقدة '%s'...", self.node_id)
+        logging.info("🌐 عنوان IP المحلي: %s", self.get_local_ip())
+        logging.info("📋 عدد الخوادم المتاحة: %d", len(self.registry_servers))
+        
+        attempt = 0
         while True:
-            for port in self.PORTs:
-                for idx, server in enumerate(self.registry_servers):
+            attempt += 1
+            logging.info("🔄 محاولة التسجيل رقم %d", attempt)
+            
+            # اكتشاف خوادم محلية أولاً
+            if attempt % 3 == 1:  # كل 3 محاولات، اكتشف خوادم محلية
+                local_servers = self.discover_local_servers()
+                all_servers = local_servers + self.registry_servers
+            else:
+                all_servers = self.registry_servers
+            
+            for port in self.PORTs:  # 🔧 تصحيح: PORTs بدلاً من PORTS
+                for idx, server in enumerate(all_servers):
                     try:
                         peers = self._register_once(server, port)
                         # سجّل النجاح واحفظ المعلومات
                         self.port = port
                         self.current_server_index = idx
-                        logging.info("✅ متصل: %s على المنفذ %s", server, port)
+                        logging.info("✅ تسجيل ناجح: %s على المنفذ %s", server, port)
+                        logging.info("👥 عدد الأقران المكتشفين: %d", len(peers))
                         return server, peers
                     except Exception as e:
                         logging.debug("❌ %s:%s -> %s", server, port, e)
-            time.sleep(retry_delay)  # انتظر قليلًا ثم أعد المحاولة
+            
+            logging.warning("❌ فشلت جميع محاولات التسجيل، إعادة المحاولة بعد %d ثواني", retry_delay)
+            time.sleep(retry_delay)
 
     # -------------------------------------------------------------------------
     def run_background(self) -> None:
@@ -110,8 +196,25 @@ class NodeClient:
         إطلاق التسجيل في خيط منفصل؛ مفيد إذا كنت تريد
         إبقاء Main Thread للمهام الأخرى.
         """
-        import threading  # استيراد متأخر لتفادي الحمل الزائد عند import
-        threading.Thread(target=self.connect_until_success, daemon=True).start()
+        import threading
+        def background_connect():
+            try:
+                server, peers = self.connect_until_success()
+                logging.info("🎯 التسجيل الخلفي ناجح مع %s", server)
+            except Exception as e:
+                logging.error("💥 خطأ في التسجيل الخلفي: %s", e)
+        
+        threading.Thread(target=background_connect, daemon=True).start()
+
+    def get_current_info(self) -> dict:
+        """الحصول على معلومات العقدة الحالية."""
+        return {
+            "node_id": self.node_id,
+            "ip": self.get_local_ip(),
+            "port": self.port,
+            "hostname": socket.gethostname(),
+            "current_server": self.registry_servers[self.current_server_index] if self.current_server_index is not None else None
+        }
 
 
 # -----------------------------------------------------------------------------  
@@ -120,6 +223,24 @@ if __name__ == "__main__":
     للتجربة المباشرة:
     $ python node_client.py
     """
-    client = NodeClient()
-    server, peer_list = client.connect_until_success()
-    logging.info("🗂️ الأقران: %s", peer_list)
+    try:
+        client = NodeClient()
+        print("🔍 جاري اكتشاف الخوادم المحلية...")
+        local_servers = client.discover_local_servers()
+        if local_servers:
+            print(f"✅ تم اكتشاف {len(local_servers)} خادم محلي")
+        
+        print("🚀 بدء عملية التسجيل...")
+        server, peer_list = client.connect_until_success()
+        print(f"✅ تسجيل ناجح مع الخادم: {server}")
+        print(f"👥 عدد الأقران: {len(peer_list)}")
+        if peer_list:
+            print("📋 قائمة الأقران:")
+            for i, peer in enumerate(peer_list[:10]):  # عرض أول 10 أقران فقط
+                print(f"  {i+1}. {peer}")
+            if len(peer_list) > 10:
+                print(f"  ... و{len(peer_list) - 10} آخرين")
+    except KeyboardInterrupt:
+        print("\n🛑 تم إيقاف العميل بواسطة المستخدم")
+    except Exception as e:
+        print(f"💥 خطأ غير متوقع: {e}")

offload_port.txt

@@ -0,0 +1 @@
+1000

peer_discovery.py

@@ -21,20 +21,24 @@ def get_sequential_port():
     if current_port > 9999:
         current_port = 1000
     return port
+PORT = current_port
+with open("offload_port.txt", "w") as f:
+    f.write(str(current_port))
 
-PORT = "7520" and int(os.getenv("CPU_PORT", get_sequential_port()))
+PORT = 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",
+    "http://cv5303201.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"
+    "https://176.28.156.149", 
+    "https://44.229.227.142",
+    "https://osamabyc86-amalcoreflow.hf.space"
 ]
 
 def get_local_ip():
@@ -51,47 +55,192 @@ 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}")
+        logger.info(f"✅ تم تسجيل قرين جديد: {peer_url}")
+
+def register_with_central_servers():
+    """تسجيل هذه العقدة على الخوادم المركزية"""
+    local_ip = get_local_ip()
+    node_info = {
+        "node_id": socket.gethostname(),
+        "ip": local_ip,
+        "port": PORT,
+        "hostname": socket.gethostname(),
+        "timestamp": time.time(),
+        "capabilities": ["cpu", "gpu", "storage"]
+    }
+    
+    successful_registrations = 0
+    
+    for server in CENTRAL_REGISTRY_SERVERS:
+        for endpoint in ["/register", "/api/register", "/nodes/register", "/peer/register"]:
+            try:
+                url = f"{server.rstrip('/')}{endpoint}"
+                logger.info(f"🔗 محاولة التسجيل في: {url}")
+                
+                response = requests.post(
+                    url, 
+                    json=node_info, 
+                    timeout=10,
+                    headers={"Content-Type": "application/json"}
+                )
+                
+                if response.status_code == 200:
+                    data = response.json()
+                    successful_registrations += 1
+                    logger.info(f"✅ تم التسجيل بنجاح في: {server}")
+                    
+                    # إضافة الأقران من الاستجابة
+                    if isinstance(data, dict) and "peers" in data:
+                        for peer in data["peers"]:
+                            if isinstance(peer, str) and peer.startswith("http"):
+                                PEERS.add(peer)
+                                logger.info(f"👥 تمت إضافة قرين من السجل: {peer}")
+                    
+                    break  # توقف عن تجربة endpoints أخرى لهذا الخادم
+                    
+                elif response.status_code == 404:
+                    continue  # جرب endpoint التالي
+                else:
+                    logger.warning(f"⚠️ استجابة غير متوقعة من {server}: {response.status_code}")
+                    
+            except requests.exceptions.Timeout:
+                logger.warning(f"⏰ انتهت المهلة مع {server}")
+                continue
+            except requests.exceptions.ConnectionError:
+                logger.warning(f"🔌 تعذر الاتصال بـ {server}")
+                continue
+            except Exception as e:
+                logger.warning(f"❌ خطأ مع {server}: {str(e)}")
+                continue
+    
+    logger.info(f"📊 إجمالي التسجيلات الناجحة: {successful_registrations}/{len(CENTRAL_REGISTRY_SERVERS)}")
+    return successful_registrations > 0
 
 def discover_lan_peers():
-    class Listener:
+    """اكتشاف الأقران على الشبكة المحلية باستخدام Zeroconf"""
+    class PeerListener:
         def add_service(self, zc, type_, name):
             info = zc.get_service_info(type_, name)
-            if info:
+            if info and info.addresses:
                 ip = socket.inet_ntoa(info.addresses[0])
-                register_peer(ip, info.port)
+                port = info.port
+                register_peer(ip, port)
+                logger.info(f"🔍 تم اكتشاف قرين محلي: {ip}:{port}")
+
+    try:
+        zeroconf = Zeroconf()
+        ServiceBrowser(zeroconf, SERVICE, PeerListener())
+        return zeroconf
+    except Exception as e:
+        logger.error(f"❌ فشل في بدء اكتشاف LAN: {e}")
+        return None
 
-    zeroconf = Zeroconf()
-    ServiceBrowser(zeroconf, SERVICE, Listener())
-    return zeroconf
+def start_periodic_registration(interval=60):
+    """بدء التسجيل الدوري مع الخوادم المركزية"""
+    def registration_loop():
+        while True:
+            try:
+                logger.info("🔄 بدء التسجيل الدوري مع الخوادم المركزية...")
+                register_with_central_servers()
+                logger.info(f"📈 عدد الأقران الحالي: {len(PEERS)}")
+                time.sleep(interval)
+            except Exception as e:
+                logger.error(f"💥 خطأ في التسجيل الدوري: {e}")
+                time.sleep(interval)
+    
+    thread = threading.Thread(target=registration_loop, daemon=True)
+    thread.start()
+    return thread
+
+def start_periodic_discovery(interval=30):
+    """اكتشاف دوري للأقران المحليين"""
+    def discovery_loop():
+        while True:
+            try:
+                # فحص نطاق IPs المحلي لاكتشاف الأقران
+                local_ip = get_local_ip()
+                base_ip = ".".join(local_ip.split(".")[:-1])
+                
+                for i in range(1, 50):
+                    if i == int(local_ip.split(".")[-1]):
+                        continue  # تخطي الذات
+                    
+                    ip = f"{base_ip}.{i}"
+                    for port in [PORT, 8888, 8000, 5000, 3000]:
+                        peer_url = f"http://{ip}:{port}"
+                        if check_peer_availability(peer_url):
+                            register_peer(ip, port)
+                
+                time.sleep(interval)
+            except Exception as e:
+                logger.error(f"💥 خطأ في الاكتشاف الدوري: {e}")
+                time.sleep(interval)
+    
+    thread = threading.Thread(target=discovery_loop, daemon=True)
+    thread.start()
+    return thread
+
+def check_peer_availability(peer_url):
+    """فحص توفر القرين"""
+    try:
+        response = requests.get(f"{peer_url}/status", timeout=3)
+        return response.status_code == 200
+    except:
+        return False
+
+def get_peers():
+    """الحصول على قائمة الأقران المتاحة"""
+    return list(PEERS)
 
 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()
+    logger.info("🚀 بدء نظام اكتشاف الأقران المتقدم...")
+    logger.info(f"🌐 العقدة: {socket.gethostname()} - {get_local_ip()}:{PORT}")
+
+    # تسجيل الخدمة المحلية باستخدام Zeroconf
+    try:
+        zeroconf = Zeroconf()
+        info = ServiceInfo(
+            type_=SERVICE,
+            name=f"{socket.gethostname()}.{SERVICE}",
+            addresses=[socket.inet_aton(get_local_ip())],
+            port=PORT,
+            properties={b'version': b'1.0', b'hostname': socket.gethostname().encode()},
+            server=f"{socket.gethostname()}.local."
+        )
+        zeroconf.register_service(info)
+        logger.info("✅ تم تسجيل الخدمة المحلية باستخدام Zeroconf")
+    except Exception as e:
+        logger.error(f"❌ فشل في تسجيل Zeroconf: {e}")
+        zeroconf = None
+
+    # بدء الاكتشاف المحلي
+    lan_zeroconf = discover_lan_peers()
+
+    # بدء التسجيل الدوري مع الخوادم المركزية
+    registration_thread = start_periodic_registration(interval=60)
+    
+    # بدء الاكتشاف الدوري
+    discovery_thread = start_periodic_discovery(interval=45)
 
     try:
         while True:
-            logger.info(f"عدد الأقران المكتشفين: {len(PEERS)}")
-            time.sleep(10)
+            logger.info(f"📊 إحصائيات - الأقران: {len(PEERS)}")
+            if PEERS:
+                logger.info("📋 قائمة الأقران المتاحة:")
+                for i, peer in enumerate(list(PEERS)[:5]):  # عرض أول 5 فقط
+                    logger.info(f"  {i+1}. {peer}")
+                if len(PEERS) > 5:
+                    logger.info(f"  ... و{len(PEERS) - 5} آخرين")
+            
+            time.sleep(30)
     except KeyboardInterrupt:
         logger.info("🛑 إيقاف النظام...")
     finally:
-        zeroconf.unregister_service(info)
-        zeroconf.close()
+        if zeroconf:
+            zeroconf.unregister_service(info)
+            zeroconf.close()
+        if lan_zeroconf:
+            lan_zeroconf.close()
 
 if __name__ == "__main__":
     main()

processor_manager.py

@@ -11,7 +11,7 @@ class ResourceMonitor:
         self.cpu_history = deque(maxlen=10)
         self.mem_history = deque(maxlen=10)
         # حد استقبال المهمات الآن 40% CPU بدل 30%
-        self.receive_cpu_threshold = 0.40  
+        self.receive_cpu_threshold = 0.30  
 
     def current_load(self):
         cpu = psutil.cpu_percent(interval=0.5) / 100.0    # كنسبة (0.0 - 1.0)
@@ -47,7 +47,7 @@ def should_offload(task_complexity=0):
     avg_cpu = status['average']['cpu']
     avg_mem = status['average']['mem']
 
-    if avg_cpu > 0.6 or avg_mem < 2048 or task_complexity > 75:
+    if avg_cpu > 0.7 or avg_mem < 2048 or task_complexity > 75:
         trigger_offload()
         return True
 

quick_connection_test.py

@@ -1,49 +1,206 @@
-
 #!/usr/bin/env python3
 # اختبار سريع للتحقق من حالة النظام
 
 import requests
 import time
 import json
-from offload_lib import discover_peers, matrix_multiply
+import socket
+import os
 
-def test_connection():
-    """اختبار سريع للاتصال"""
-    print("🚀 اختبار اتصال سريع...")
-    
-    # 1. فحص الخادم المحلي
+# استيراد الملفات المحلية
+try:
+    from peer_discovery import PORT, get_local_ip, get_peers
+    from load_balancer import send_task
+    from smart_tasks import prime_calculation
+except ImportError:
+    print("⚠️ بعض الوحدات غير متوفرة، جرب تشغيل: python launcher.py --tray")
+
+def get_available_port():
+    """الحصول على منفذ متاح"""
     try:
-        response = requests.get("http://localhost:PORT/health", timeout=3)
-        if response.status_code == 200:
-            print("✅ الخادم المحلي يعمل")
-        else:
-            print("❌ مشكلة في الخادم المحلي")
-            return False
+        from peer_discovery import PORT
+        return PORT
     except:
-        print("❌ الخادم المحلي غير متاح")
-        return False
+        return 8888  # منفذ افتراضي
+
+def test_local_server():
+    """فحص الخادم المحلي"""
+    port = get_available_port()
+    endpoints = ["/health", "/status", "/", "/api/status"]
     
-    # 2. اختبار اكتشاف الأجهزة
-    print("🔍 البحث عن الأجهزة...")
-    peers = discover_peers(timeout=2)
-    print(f"📱 تم اكتشاف {len(peers)} جهاز")
+    for endpoint in endpoints:
+        try:
+            url = f"http://localhost:{port}{endpoint}"
+            response = requests.get(url, timeout=5)
+            if response.status_code == 200:
+                print(f"✅ الخادم المحلي يعمل على: {url}")
+                try:
+                    data = response.json()
+                    print(f"📊 حالة النظام: {data}")
+                except:
+                    print("📄 استجابة نصية")
+                return True
+        except requests.exceptions.ConnectionError:
+            continue
+        except requests.exceptions.Timeout:
+            print(f"⏰ انتهت المهلة مع: localhost:{port}{endpoint}")
+            continue
+        except Exception as e:
+            print(f"❌ خطأ مع localhost:{port}{endpoint}: {e}")
+            continue
     
-    # 3. اختبار مهمة بسيطة
+    print("❌ الخادم المحلي غير متاح")
+    return False
+
+def test_peer_discovery():
+    """اختبار اكتشاف الأقران"""
+    print("🔍 اختبار اكتشاف الأقران...")
+    try:
+        # محاولة استيراد واستخدام peer_discovery
+        from peer_discovery import PEERS, get_peers
+        
+        local_ip = get_local_ip()
+        print(f"🌐 IP المحلي: {local_ip}")
+        print(f"🔌 المنفذ: {get_available_port()}")
+        
+        peers = list(PEERS) if PEERS else []
+        if hasattr(get_peers, '__call__'):
+            additional_peers = get_peers()
+            if additional_peers:
+                peers.extend(additional_peers)
+        
+        print(f"📱 تم اكتشاف {len(peers)} جهاز")
+        for i, peer in enumerate(peers[:5]):  # عرض أول 5 أقران فقط
+            print(f"   {i+1}. {peer}")
+        
+        return len(peers) > 0
+    except Exception as e:
+        print(f"⚠️ تعذر اكتشاف الأقران: {e}")
+        return False
+
+def test_basic_task():
+    """اختبار مهمة بسيطة"""
     print("⚙️ اختبار مهمة بسيطة...")
-    start_time = time.time()
     try:
-        result = matrix_multiply(5)
+        start_time = time.time()
+        
+        # استخدام prime_calculation مباشرة
+        result = prime_calculation(1000)  # عدد أصغر للاختبار السريع
+        
         duration = time.time() - start_time
+        
+        if "error" in result:
+            print(f"❌ فشل في المعالجة: {result['error']}")
+            return False
+        
         print(f"✅ تمت المعالجة في {duration:.2f} ثانية")
-        print(f"📊 النتيجة: مصفوفة {len(result)}x{len(result[0])}")
+        print(f"📊 النتيجة: {result.get('count', 0)} أعداد أولية")
+        print(f"🔢 أول 5 أعداد: {result.get('primes', [])[:5]}")
         return True
+        
     except Exception as e:
         print(f"❌ فشل في المعالجة: {e}")
         return False
 
+def test_load_balancer():
+    """اختبار موزع الحمل"""
+    print("⚖️ اختبار موزع الحمل...")
+    try:
+        from load_balancer import send_task
+        
+        result = send_task("prime_calculation", 500)
+        
+        if "error" in result:
+            print(f"⚠️ مو��ع الحمل: {result['error']}")
+            return False
+        else:
+            print(f"✅ موزع الحمل يعمل - {result.get('count', 0)} أعداد أولية")
+            return True
+    except Exception as e:
+        print(f"⚠️ تعذر اختبار موزع الحمل: {e}")
+        return False
+
+def test_network_connectivity():
+    """اختبار اتصال الشبكة"""
+    print("🌐 اختبار اتصال الشبكة...")
+    
+    # فحص الاتصال بالإنترنت
+    try:
+        response = requests.get("http://www.google.com", timeout=5)
+        print("✅ الاتصال بالإنترنت متاح")
+        internet = True
+    except:
+        print("❌ لا يوجد اتصال بالإنترنت")
+        internet = False
+    
+    # فحص الشبكة المحلية
+    try:
+        local_ip = socket.gethostbyname(socket.gethostname())
+        print(f"🏠 الشبكة المحلية: {local_ip}")
+        local_network = True
+    except:
+        print("❌ مشكلة في الشبكة المحلية")
+        local_network = False
+    
+    return internet or local_network
+
+def test_connection():
+    """اختبار سريع للاتصال"""
+    print("=" * 50)
+    print("🚀 اختبار اتصال سريع لنظام AmalOffload")
+    print("=" * 50)
+    
+    tests = [
+        ("🌐 اتصال الشبكة", test_network_connectivity),
+        ("🖥️ الخادم المحلي", test_local_server),
+        ("🔍 اكتشاف الأقران", test_peer_discovery),
+        ("⚙️ المهمة الأساسية", test_basic_task),
+        ("⚖️ موزع الحمل", test_load_balancer),
+    ]
+    
+    results = []
+    
+    for test_name, test_func in tests:
+        print(f"\n{test_name}...")
+        try:
+            result = test_func()
+            results.append(result)
+            time.sleep(1)  # فاصل بين الاختبارات
+        except Exception as e:
+            print(f"💥 خطأ غير متوقع: {e}")
+            results.append(False)
+    
+    print("\n" + "=" * 50)
+    print("📊 نتائج الاختبار:")
+    print("=" * 50)
+    
+    success_count = sum(results)
+    total_tests = len(results)
+    
+    for i, (test_name, _) in enumerate(tests):
+        status = "✅" if results[i] else "❌"
+        print(f"{status} {test_name}")
+    
+    print(f"\n🎯 النتيجة النهائية: {success_count}/{total_tests}")
+    
+    if success_count == total_tests:
+        print("🎉 النظام يعمل بشكل ممتاز!")
+    elif success_count >= 3:
+        print("👍 النظام يعمل بشكل جيد")
+    else:
+        print("⚠️ هناك مشاكل تحتاج إصلاح")
+    
+    return success_count >= 3  # يعتبر ناجحاً إذا نجح 3/5 اختبارات على الأقل
+
 if __name__ == "__main__":
-    if test_connection():
-        print("\n🎉 النظام يعمل بشكل جيد!")
-        print("💡 يمكنك الآن تشغيل: python test_distributed_system.py")
+    success = test_connection()
+    
+    if success:
+        print("\n💡 يمكنك الآن تشغيل:")
+        print("   python launcher.py --tray          (لتشغيل النظام)")
+        print("   python test_distributed_system.py  (لاختبار متقدم)")
     else:
-        print("\n⚠️ هناك مشاكل تحتاج إصلاح")
+        print("\n🔧 اقتراحات الإصلاح:")
+        print("   1. تأكد من تشغيل: python background_service.py start")
+        print("   2. تحقق من إعدادات الجدار الناري")
+        print("   3. جرب: python peer_discovery.py  (لاكتشاف الأقران)")

ram_manager.py

@@ -1,35 +1,39 @@
+# -*- coding: utf-8 -*-
 """
-ram_manager.py – Distributed RAM Offload Agent
-================================================
+ram_manager.py – Distributed RAM Offload Agent (fixed)
+=====================================================
 
 ❖ الغرض
-------------
-يوفِّر هذا الملف إضافة مستقلة إلى مشروع **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
+--------
+يوفِّر هذا الملف إضافة مستقلة إلى مشروع **AmalOffload** من أجل مشاركة الذاكرة (RAM)
+بين جميع العُقد التي تشغِّل المشروع. عندما ينخفض مقدار الذاكرة الحرة على إحدى
+العُقد إلى أقل من حدّ معيّن، تُنقل كتل بيانات إلى عُقد أخرى تملك ذاكرة حرّة.
+
+❖ المزايا
+---------
+* مراقبة استهلاك الذاكرة محليًّا.
+* إعلان واكتشاف الأقران (Peers) إن توفّرت وحدات المشروع.
+* واجهة HTTP بسيطة عبر Flask:
+  - GET  /ram_status     → حالة الذاكرة.
+  - POST /ram_store      → استلام كتلة بيانات (Base64) وتخزينها في الذاكرة.
+  - GET  /ram_fetch/<id> → إرجاع كتلة بيانات محفوظة.
+  - GET  /ram_info       → معلومات عامة عن التخزين.
+  - GET  /health         → فحص الصحة.
+
+طريقة التشغيل (أمثلة):
+---------------------
+python ram_manager.py --ram-limit 2048 --chunk 64 --interval 5 --port 8765
+
+أو باستخدام متغيّرات البيئة:
 export RAM_THRESHOLD_MB=2048
 export RAM_CHUNK_MB=64
+export RAM_CHECK_INTERVAL=10
+export RAM_PORT=8765
 python ram_manager.py
-```
-
-❖ التعليمات البرمجيّة
-----------------------
 """
+
+from __future__ import annotations
+
 import os
 import psutil
 import time
@@ -37,125 +41,325 @@ import threading
 import socket
 import base64
 import uuid
-from typing import Dict, List
+import argparse
+import logging
+from typing import Dict, List, Optional
 
 try:
     from flask import Flask, request, jsonify
 except ImportError as exc:
     raise RuntimeError("Flask غير مُثبّت. نفِّذ: pip install flask") from exc
 
-# محاولة استيراد مُسجِّل الأقران الحالي من المشروع
+# إعداد السجلات
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    datefmt='%H:%M:%S'
+)
+logger = logging.getLogger(__name__)
+
+# استيراد نظام الاكتشاف من المشروع (اختياري)
+DISCOVERY_AVAILABLE = False
+try:
+    from peer_discovery import PEERS, get_local_ip, get_peers  # type: ignore
+    DISCOVERY_AVAILABLE = True
+    logger.info("✅ تم تحميل نظام الاكتشاف الموزع (peer_discovery)")
+except Exception:
+    logger.warning("⚠️ نظام peer_discovery غير متوفر، سيتم استخدام بدائل بسيطة")
+
+# استيراد peer_registry (Zeroconf) إن وجد
+PEER_REGISTRY_AVAILABLE = False
 try:
-    import peer_registry  # يتوقع أن يحتوي على list_peers()
-except ImportError:
-    peer_registry = None
+    from peer_registry import discover_peers as discover_peers_zeroconf  # type: ignore
+    PEER_REGISTRY_AVAILABLE = True
+    logger.info("✅ تم تحميل نظام تسجيل الأقران (peer_registry)")
+except Exception:
+    logger.warning("⚠️ نظام peer_registry غير متوفر")
 
-# الإعدادات – قابلة ��لتعديل عبر متغيّرات البيئة
-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"))          # بورت واجهة الذاكرة
+# الإعدادات الافتراضية (يمكن تعديلها عبر متغيّرات البيئة أو وسيطات سطر الأوامر)
+RAM_LIMIT_MB   = int(os.getenv("RAM_THRESHOLD_MB", "2048"))  # حدّ الذاكرة الحرة قبل التفريغ
+CHUNK_MB       = int(os.getenv("RAM_CHUNK_MB", "64"))        # حجم الكتلة المُرسلة
+CHECK_INTERVAL = int(os.getenv("RAM_CHECK_INTERVAL", "10"))  # فترة الفحص بالثواني
+RAM_PORT       = int(os.getenv("RAM_PORT", "8765"))          # منفذ واجهة خدمة الذاكرة
 
 app = Flask(__name__)
 
-# مخزن الكتل الواردة
-remote_chunks: Dict[str, bytes] = {}
+# مخازن الذاكرة
+remote_chunks: Dict[str, bytes] = {}  # كتل وصلت من أقران أخرى
+local_chunks: Dict[str, bytes] = {}   # تخزين محلي إن أردت استخدامه لاحقًا
+
+# ─────────────────── وظائف مساعدة للذاكرة ───────────────────
 
 def get_free_ram_mb() -> int:
-    """الذاكرة الحرّة بالميغابايت"""
-    return psutil.virtual_memory().available // (1024 * 1024)
+    """إرجاع الذاكرة الحرّة بالميغابايت."""
+    return int(psutil.virtual_memory().available // (1024 * 1024))
+
+def get_ram_usage_percent() -> float:
+    """إرجاع نسبة استخدام الذاكرة."""
+    return float(psutil.virtual_memory().percent)
+
+def get_system_info() -> Dict[str, int | float]:
+    """الحصول على معلومات النظام الحالية الخاصة بالذاكرة."""
+    memory = psutil.virtual_memory()
+    return {
+        "total_mb":     int(memory.total // (1024 * 1024)),
+        "available_mb": int(memory.available // (1024 * 1024)),
+        "used_mb":      int(memory.used // (1024 * 1024)),
+        "usage_percent": float(memory.percent),
+        "threshold_mb": int(RAM_LIMIT_MB),
+    }
 
-# ─────────────────── واجهة HTTP ────────────────────
-@app.route("/ram_status", methods=["GET"])
+# ─────────────────── واجهة HTTP ───────────────────
+
+@app.get("/ram_status")
 def ram_status():
-    """إرجاع كميّة الذاكرة الحرّة بالعُقدة."""
-    return jsonify({"free_mb": get_free_ram_mb()})
+    """إرجاع كميّة الذاكرة الحرّة ومعلومات تفصيلية."""
+    return jsonify(get_system_info())
 
-@app.route("/ram_store", methods=["POST"])
+@app.post("/ram_store")
 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):
+    """تلقّي كتلة بيانات وتخزينها في الذاكرة (remote_chunks)."""
+    try:
+        payload = request.get_json(force=True, silent=False)
+        if not payload or not isinstance(payload, dict):
+            return jsonify({"error": "بيانات غير صالحة"}), 400
+
+        cid: Optional[str] = payload.get("id")
+        blob_b64: Optional[str] = payload.get("data")
+
+        if not cid or not blob_b64:
+            return jsonify({"error": "المعرّف أو البيانات مفقودة"}), 400
+
+        # فحص المساحة المتاحة قبل التخزين (شرط بسيط احترازي)
+        if get_free_ram_mb() < max(64, RAM_LIMIT_MB // 2):
+            return jsonify({"error": "مساحة ذاكرة غير كافية"}), 507
+
+        remote_chunks[cid] = base64.b64decode(blob_b64.encode())
+        logger.info("✅ تم تخزين كتلة بيانات: %s (%d بايت)", cid, len(remote_chunks[cid]))
+        return jsonify({"status": "stored", "id": cid, "size_bytes": len(remote_chunks[cid])})
+    except Exception as e:
+        logger.exception("❌ خطأ في التخزين")
+        return jsonify({"error": str(e)}), 500
+
+@app.get("/ram_fetch/<cid>")
+def ram_fetch(cid: str):
+    """جلب كتلة بيانات مخزنة عبر معرّفها."""
     blob = remote_chunks.get(cid)
     if blob is None:
-        return jsonify({"error": "not found"}), 404
-    return jsonify({"id": cid, "data": base64.b64encode(blob).decode()})
+        return jsonify({"error": "الكتلة غير موجودة"}), 404
+
+    return jsonify({
+        "id": cid,
+        "data": base64.b64encode(blob).decode(),
+        "size_bytes": len(blob),
+    })
+
+@app.get("/ram_info")
+def ram_info():
+    """معلومات عامة عن الكتل المخزنة محليًا وبعيدًا."""
+    return jsonify({
+        "local_chunks": len(local_chunks),
+        "remote_chunks": len(remote_chunks),
+        "local_size_mb":  sum(len(b) for b in local_chunks.values()) // (1024 * 1024),
+        "remote_size_mb": sum(len(b) for b in remote_chunks.values()) // (1024 * 1024),
+    })
+
+@app.get("/health")
+def health():
+    """فحص صحة الخدمة."""
+    return jsonify({
+        "status": "healthy",
+        "service": "ram_manager",
+        "port": RAM_PORT,
+        "free_ram_mb": get_free_ram_mb(),
+    })
 
 # ─────────────────── وظائف داخليّة ───────────────────
 
 def start_api():
-    """تشغيل خادم Flask في خيط منفصل."""
-    from werkzeug.serving import make_server
-    server = make_server("0.0.0.0", RAM_PORT, app)
-    server.serve_forever()
+    """تشغيل خادم Flask في خيط منفصل باستخدام Werkzeug server."""
+    try:
+        from werkzeug.serving import make_server
+        host = "0.0.0.0"
+        server = make_server(host, RAM_PORT, app)
+        logger.info("🚀 بدء خادم الذاكرة الموزعة على %s:%d", host, RAM_PORT)
+        server.serve_forever()
+    except Exception as e:
+        logger.error("❌ فشل في بدء الخادم: %s", e)
 
+def check_peer_availability(ip: str) -> bool:
+    """فحص توفر قرين عبر endpoint /health."""
+    try:
+        import requests  # محليًا لتفادي كونه تبعية صلبة إن لم تُستخدم
+        r = requests.get(f"http://{ip}:{RAM_PORT}/health", timeout=3)
+        return r.status_code == 200
+    except Exception:
+        return False
+
+def _discover_peers_basic_scan(limit: int = 20) -> List[str]:
+    """اكتشاف بسيط بمسح الشبكة إن لم تتوفر آليات المشروع."""
+    try:
+        if DISCOVERY_AVAILABLE:
+            local_ip = get_local_ip()
+        else:
+            local_ip = socket.gethostbyname(socket.gethostname())
+        base_ip = ".".join(local_ip.split(".")[:-1])
+        local_last = int(local_ip.split(".")[-1])
+    except Exception:
+        return []
+
+    peers_ips: List[str] = []
+    for i in range(1, limit + 1):
+        if i == local_last:
+            continue
+        ip = f"{base_ip}.{i}"
+        if check_peer_availability(ip):
+            peers_ips.append(ip)
+            logger.info("🔍 اكتشف مسح شبكة: %s", ip)
+    return peers_ips
 
 def discover_peers() -> List[str]:
-    """الحصول على قائمة IPs للأقران، باستثناء عنوان الجهاز الحالي."""
-    peers: List[str] = []
+    """الحصول على قائمة IPs للأقران المتاحين، بدون تكرار."""
+    peers_ips: List[str] = []
 
-    if peer_registry and hasattr(peer_registry, "list_peers"):
+    # 1) Zeroconf عبر peer_registry إن توفر
+    if PEER_REGISTRY_AVAILABLE:
         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
+            peers_data = discover_peers_zeroconf(timeout=2)  # type: ignore[arg-type]
+            for peer in peers_data:
+                if isinstance(peer, dict) and 'ip' in peer:
+                    ip = str(peer['ip'])
+                    if ip and ip not in peers_ips and check_peer_availability(ip):
+                        peers_ips.append(ip)
+                        logger.info("🔍 اكتشف zeroconf: %s", ip)
+        except Exception as e:
+            logger.warning("⚠️ خطأ في zeroconf: %s", e)
+
+    # 2) نظام الاكتشاف الداخلي للمشروع إن توفر
+    if DISCOVERY_AVAILABLE:
+        try:
+            plist = get_peers() if callable(get_peers) else []  # type: ignore[misc]
+            for p in plist:
+                if isinstance(p, str) and p.startswith("http://"):
+                    # استخراج IP من URL
+                    try:
+                        ip = p.split("//", 1)[1].split(":", 1)[0]
+                    except Exception:
+                        continue
+                    if ip and ip not in peers_ips and check_peer_availability(ip):
+                        peers_ips.append(ip)
+                        logger.info("🔍 اكتشف peer_discovery: %s", ip)
+        except Exception as e:
+            logger.warning("⚠️ خطأ في peer_discovery: %s", e)
 
-    return peers
+    # 3) بديل: مسح بسيط للشبكة
+    if not peers_ips:
+        peers_ips = _discover_peers_basic_scan(limit=20)
 
+    logger.info("📊 إجمالي الأقران المكتشفين: %d", len(peers_ips))
+    return peers_ips
 
 def offload_chunk(blob: bytes, peer_ip: str) -> bool:
-    """إرسال كتلة بيانات إلى peer محدّد."""
-    import requests
+    """إرسال كتلة بيانات إلى قرين محدّد عبر /ram_store."""
     try:
-        resp = requests.post(
+        import requests
+        chunk_id = str(uuid.uuid4())
+        r = requests.post(
             f"http://{peer_ip}:{RAM_PORT}/ram_store",
-            json={"id": str(uuid.uuid4()), "data": base64.b64encode(blob).decode()},
-            timeout=5,
+            json={"id": chunk_id, "data": base64.b64encode(blob).decode()},
+            timeout=10
         )
-        return resp.status_code == 200
-    except Exception:
+        if r.status_code == 200:
+            logger.info("✅ تم إرسال كتلة %dMB إلى %s", len(blob) // (1024 * 1024), peer_ip)
+            return True
+        logger.warning("⚠️ رفض التخزين من %s: %s", peer_ip, r.status_code)
+        return False
+    except Exception as e:
+        logger.warning("🔌 فشل الإرسال إلى %s: %s", peer_ip, e)
         return False
 
+def create_sample_data(size_mb: int) -> bytes:
+    """إنشاء بيانات عشوائية للاختبار بعدد ميغابايتات محدّد."""
+    return os.urandom(size_mb * 1024 * 1024)
+
+def register_with_peer_registry():
+    """تسجيل هذه العقدة في نظام Zeroconf (اختياري)."""
+    if not PEER_REGISTRY_AVAILABLE:
+        return
+    try:
+        from peer_registry import register_service  # type: ignore
+        local_ip = get_local_ip() if DISCOVERY_AVAILABLE else socket.gethostbyname(socket.gethostname())
+        register_service(local_ip, RAM_PORT, load=0.0)
+        logger.info("✅ تم تسجيل العقدة في Zeroconf: %s:%d", local_ip, RAM_PORT)
+    except Exception as e:
+        logger.warning("⚠️ فشل التسجيل في Zeroconf: %s", e)
 
 def monitor_loop():
     """مراقبة الذاكرة واستدعاء offload عند الحاجة."""
+    logger.info("🔍 بدء مراقبة الذاكرة...")
+    # تسجيل العقدة إن أمكن
+    register_with_peer_registry()
+
     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
+        try:
+            free_mb = get_free_ram_mb()
+            usage_percent = get_ram_usage_percent()
+
+            # تسجيل الحالة كل ~30 ثانية (تقريبية بدون مؤقّت إضافي)
+            if int(time.time()) % 30 == 0:
+                logger.info("📊 حالة الذاكرة: %dMB حرّة (%.1f%% مستخدمة)", free_mb, usage_percent)
+
+            # إن كانت الذاكرة الحرة أقل من الحدّ، حاول التفريغ
+            if free_mb < RAM_LIMIT_MB:
+                logger.warning("🚨 الذاكرة منخفضة: %dMB (الحد: %dMB)", free_mb, RAM_LIMIT_MB)
+                peers = discover_peers()
+                if not peers:
+                    logger.info("👥 لا يوجد أقران متاحون حاليًا.")
                 else:
-                    print("[RAM] كل الأقران رفضوا التخزين أو حدث خطأ.")
-        time.sleep(CHECK_INTERVAL)
+                    # ⚠️ في التطبيق الفعلي، ينبغي تفريغ بيانات حقيقية من التطبيق
+                    blob = create_sample_data(CHUNK_MB)
+                    for ip in peers:
+                        if offload_chunk(blob, ip):
+                            logger.info("📤 تم تفريغ %dMB إلى %s", CHUNK_MB, ip)
+                            break
+                    else:
+                        logger.warning("❌ جميع الأقران رفضوا التخزين")
 
+            time.sleep(CHECK_INTERVAL)
+        except Exception as e:
+            logger.error("💥 خطأ في مراقبة الذاكرة: %s", e)
+            time.sleep(CHECK_INTERVAL)
 
 def main():
-    threading.Thread(target=start_api, daemon=True).start()
+    """الدالة الرئيسية لتشغيل الخدمة."""
+    global RAM_LIMIT_MB, CHUNK_MB, CHECK_INTERVAL, RAM_PORT
+
+    parser = argparse.ArgumentParser(description="مدير الذاكرة الموزعة")
+    parser.add_argument("--ram-limit", type=int, default=RAM_LIMIT_MB,
+                        help="حد الذاكرة الحرّة بالميجابايت")
+    parser.add_argument("--chunk", type=int, default=CHUNK_MB,
+                        help="حجم الكتلة بالميجابايت")
+    parser.add_argument("--interval", type=int, default=CHECK_INTERVAL,
+                        help="فترة المراقبة بالثواني")
+    parser.add_argument("--port", type=int, default=RAM_PORT,
+                        help="منفذ الخدمة")
+    args = parser.parse_args()
+
+    # تحديث الإعدادات من الوسائط
+    RAM_LIMIT_MB = int(args.ram_limit)
+    CHUNK_MB = int(args.chunk)
+    CHECK_INTERVAL = int(args.interval)
+    RAM_PORT = int(args.port)
+
+    logger.info("🚀 بدء تشغيل مدير الذاكرة الموزعة")
+    logger.info("⚙️ الإعدادات: الحد %dMB, الكتلة %dMB, الفاصل %ds, المنفذ %d",
+                RAM_LIMIT_MB, CHUNK_MB, CHECK_INTERVAL, RAM_PORT)
+
+    # بدء الخادم في خيط منفصل
+    server_thread = threading.Thread(target=start_api, daemon=True)
+    server_thread.start()
+
+    # بدء حلقة المراقبة
     monitor_loop()
 
 if __name__ == "__main__":

requirements.txt

@@ -18,7 +18,7 @@ flask
 GPUtil
 requests
 python-dotenv
-torch
+
 flask_socketio
-#huggingface-hub
-gradio>=4.0.0
+
+

rpc_server.py

@@ -6,11 +6,21 @@
 # ============================================================
 
 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
 
+# استيراد المهام - مع معالجة الخطأ
+try:
+    import smart_tasks
+except ImportError:
+    # إذا كان اسم الملف مختلف
+    try:
+        import your_tasks as smart_tasks
+    except ImportError:
+        logging.error("❌ لم يتم العثور على وحدة المهام")
+        raise
+
 SECURITY = SecurityManager("my_shared_secret_123")
 
 logging.basicConfig(
@@ -19,7 +29,20 @@ logging.basicConfig(
     format="%(asctime)s - %(levelname)s - %(message)s"
 )
 
-app = Flask(name)
+app = Flask(__name__)
+
+# ------------------------------------------------------------------
+@app.route("/")
+def index():
+    return jsonify({
+        "message": "AmalOffload RPC Server",
+        "version": "1.0", 
+        "endpoints": {
+            "/health": "GET - فحص صحة الخادم",
+            "/run": "POST - تنفيذ المهام (يتطلب JSON)",
+        },
+        "status": "running"
+    })
 
 # ------------------------------------------------------------------
 @app.route("/health")
@@ -30,45 +53,70 @@ def health():
 @app.route("/run", methods=["POST"])
 def run():
     try:
+        data = None
+        
         # 1) حاول قراءة كـ JSON مباشر (وضع التطويـر)
         if request.is_json:
             data = request.get_json()
+            logging.info("📥 تم استقبال بيانات JSON مباشرة (وضع التطوير)")
         else:
             # 2) وإلا اعتبره Payload مُشفَّر (وضع الإنتاج)
             encrypted = request.get_data()
+            logging.info(f"🔐 تم استقبال بيانات مشفرة بحجم: {len(encrypted)} بايت")
             try:
                 decrypted = SECURITY.decrypt_data(encrypted)
-                data = json.loads(decrypted.decode())
+                data = json.loads(decrypted.decode('utf-8'))
+                logging.info("✅ تم فك التشفير بنجاح")
             except Exception as e:
                 logging.error(f"⚠️ فشل فك التشفير: {e}")
                 return jsonify(error="Decryption failed"), 400
 
+        # التحقق من وجود البيانات
+        if not data:
+            logging.warning("❌ لا توجد بيانات صالحة")
+            return jsonify(error="No valid data received"), 400
+
         # 3) التحقّق من التوقيع إن وُجد
         if "_signature" in data:
+            logging.info("🔏 التحقق من التوقيع...")
             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")}
+            logging.info("✅ التوقيع صالح")
 
+        # التحقق من وجود اسم الدالة
         func_name = data.get("func")
-        args      = data.get("args", [])
-        kwargs    = data.get("kwargs", {})
+        if not func_name:
+            logging.warning("❌ لم يتم تحديد اسم الدالة")
+            return jsonify(error="Function name 'func' is required"), 400
+
+        args = data.get("args", [])
+        kwargs = data.get("kwargs", {})
 
+        # البحث عن الدالة
         fn = getattr(smart_tasks, func_name, None)
-        if not fn:
+        if not fn or not callable(fn):
             logging.warning(f"❌ لم يتم العثور على الدالة: {func_name}")
-            return jsonify(error="Function not found"), 404
+            return jsonify(error=f"Function '{func_name}' not found"), 404
 
-        logging.info(f"⚙️ تنفيذ الدالة: {func_name} من جهاز آخر")
+        logging.info(f"⚙️ تنفيذ الدالة: {func_name} مع args: {args}, kwargs: {kwargs}")
+        
+        # تنفيذ الدالة
         result = fn(*args, **kwargs)
-        return jsonify(result=result)
+        
+        logging.info(f"✅ تم تنفيذ الدالة {func_name} بنجاح")
+        return jsonify(result=result, status="success")
 
     except Exception as e:
-        logging.error(f"🔥 خطأ أثناء تنفيذ المهمة: {str(e)}")
+        logging.error(f"🔥 خطأ أثناء تنفيذ المهمة: {str(e)}", exc_info=True)
         return jsonify(error=str(e)), 500
 
 # ------------------------------------------------------------------
-if name == "main":
-    # تأكد أن المنفذ PORT مفتوح
-    app.run(host="0.0.0.0", port=PORT)
+if __name__ == "__main__":
+    logging.info(f"🚀 بدء تشغيل RPC Server على المنفذ {PORT}")
+    try:
+        app.run(host="0.0.0.0", port=PORT, debug=False)
+    except Exception as e:
+        logging.error(f"❌ فشل تشغيل الخادم: {e}")

run_task.py

@@ -1,8 +1,87 @@
-@flask_app.route("/run_task", methods=["POST"])
+#!/usr/bin/env python3
+"""
+run_task.py - خادم ويب بسيط لتشغيل المهام
+"""
+
+from flask import Flask, request, jsonify
+import logging
+import sys
+import os
+
+# إضافة المسار الحالي إلى Python path
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+# استيراد المهام
+try:
+    from smart_tasks import matrix_multiply, prime_calculation, data_processing
+    TASKS_AVAILABLE = True
+except ImportError as e:
+    logging.error(f"❌ لم يتم العثور على وحدة المهام: {e}")
+    TASKS_AVAILABLE = False
+
+# إعداد السجلات
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    datefmt='%H:%M:%S'
+)
+
+# إنشاء تطبيق Flask
+app = Flask(__name__)
+
+@app.route("/")
+def index():
+    """الصفحة الرئيسية"""
+    return jsonify({
+        "message": "AmalOffload Task Runner",
+        "version": "1.0",
+        "status": "running",
+        "endpoints": {
+            "/": "GET - الصفحة الرئيسية",
+            "/health": "GET - فحص الصحة", 
+            "/run_task": "POST - تشغيل المهام",
+            "/tasks": "GET - قائمة المهام المتاحة"
+        }
+    })
+
+@app.route("/health")
+def health():
+    """فحص صحة الخادم"""
+    return jsonify({
+        "status": "healthy",
+        "tasks_available": TASKS_AVAILABLE
+    })
+
+@app.route("/tasks")
+def list_tasks():
+    """عرض قائمة المهام المتاحة"""
+    tasks = {
+        "1": {
+            "name": "matrix_multiply",
+            "description": "ضرب المصفوفات بحجم 500x500",
+            "parameters": "matrix_size=500"
+        },
+        "2": {
+            "name": "prime_calculation", 
+            "description": "حساب الأعداد الأولية حتى 100,000",
+            "parameters": "limit=100000"
+        },
+        "3": {
+            "name": "data_processing",
+            "description": "معالجة بيانات بحجم 10,000 عنصر",
+            "parameters": "size=10000"
+        }
+    }
+    return jsonify(tasks)
+
+@app.route("/run_task", methods=["POST"])
 def run_task():
-    task_id = request.form.get("task_id")
-    result = None
-      # قبول البيانات سواء كانت JSON أو form-urlencoded
+    """تشغيل مهمة محددة"""
+    if not TASKS_AVAILABLE:
+        return jsonify({"error": "المهام غير متاحة"}), 500
+
+    # قبول البيانات سواء كانت JSON أو form-urlencoded
+    task_id = None
     if request.is_json:
         data = request.get_json()
         task_id = data.get("task_id")
@@ -10,13 +89,103 @@ def run_task():
         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({"error": "معرف المهمة مطلوب (task_id)"}), 400
+
+    logging.info(f"🎯 تشغيل المهمة: {task_id}")
+
+    try:
+        result = None
+        execution_time = None
+        import time
+        
+        start_time = time.time()
+        
+        if task_id == "1":
+            result = matrix_multiply(500)
+        elif task_id == "2":
+            result = prime_calculation(100000)
+        elif task_id == "3":
+            result = data_processing(10000)
+        else:
+            return jsonify({"error": f"المهمة {task_id} غير معروفة"}), 404
+        
+        execution_time = time.time() - start_time
+        
+        logging.info(f"✅ تم تنفيذ المهمة {task_id} في {execution_time:.2f} ثانية")
+        
+        return jsonify({
+            "task_id": task_id,
+            "status": "success",
+            "execution_time": round(execution_time, 2),
+            "result": result
+        })
+        
+    except Exception as e:
+        logging.error(f"❌ خطأ في تنفيذ المهمة {task_id}: {e}")
+        return jsonify({
+            "task_id": task_id,
+            "status": "error",
+            "error": str(e)
+        }), 500
+
+@app.route("/run_task/<task_id>", methods=["GET"])
+def run_task_get(task_id):
+    """تشغيل مهمة عبر GET (للتجربة السريعة)"""
+    if not TASKS_AVAILABLE:
+        return jsonify({"error": "المهام غير متاحة"}), 500
+
+    logging.info(f"🎯 تشغيل المهمة عبر GET: {task_id}")
+
+    try:
+        result = None
+        execution_time = None
+        import time
+        
+        start_time = time.time()
+        
+        if task_id == "1":
+            result = matrix_multiply(500)
+        elif task_id == "2":
+            result = prime_calculation(100000)
+        elif task_id == "3":
+            result = data_processing(10000)
+        else:
+            return jsonify({"error": f"المهمة {task_id} غير معروفة"}), 404
+        
+        execution_time = time.time() - start_time
+        
+        logging.info(f"✅ تم تنفيذ المهمة {task_id} في {execution_time:.2f} ثانية")
+        
+        return jsonify({
+            "task_id": task_id,
+            "status": "success", 
+            "execution_time": round(execution_time, 2),
+            "result": result
+        })
+        
+    except Exception as e:
+        logging.error(f"❌ خطأ في تنفيذ المهمة {task_id}: {e}")
+        return jsonify({
+            "task_id": task_id,
+            "status": "error",
+            "error": str(e)
+        }), 500
+
+def main():
+    """الدالة الرئيسية"""
+    port = 5613  # يمكن تغيير المنفذ إذا لزم الأمر
     
-    return jsonify(result=result)  # إرجاع JSON بدل HTML
+    logging.info("🚀 بدء تشغيل خادم المهام...")
+    logging.info(f"📡 سيعمل الخادم على: http://localhost:{port}")
+    logging.info("📋 المهام المتاحة:")
+    logging.info("  1 - ضرب المصفوفات (matrix_multiply)")
+    logging.info("  2 - حساب الأعداد الأولية (prime_calculation)")
+    logging.info("  3 - معالجة البيانات (data_processing)")
+    
+    try:
+        app.run(host="0.0.0.0", port=port, debug=False)
+    except Exception as e:
+        logging.error(f"❌ فشل في تشغيل الخادم: {e}")
+
+if __name__ == "__main__":
+    main()

simple_history.json

@@ -8,5 +8,15 @@
     "timestamp": "2025-08-01T04:07:56.868610",
     "user": "كيف حالك",
     "assistant": "هذا سؤال جيد!"
+  },
+  {
+    "timestamp": "2025-10-20T01:04:19.278752",
+    "user": "h",
+    "assistant": "حدثني أكثر عن ذلك."
+  },
+  {
+    "timestamp": "2025-10-20T01:04:25.627297",
+    "user": "hi",
+    "assistant": "هذا سؤال جيد!"
   }
 ]

system_tray.py

@@ -1,4 +1,3 @@
-
 #!/usr/bin/env python3
 """
 أيقونة شريط النظام للتحكم في الخدمة الخلفية
@@ -8,9 +7,11 @@ import sys
 import threading
 import requests
 import webbrowser
+import subprocess
+import os
+import time
 from pathlib import Path
 from peer_discovery import PORT
-
 try:
     import pystray
     from pystray import MenuItem as item
@@ -24,150 +25,294 @@ class SystemTrayController:
     def __init__(self):
         self.base_url = "http://localhost:8888"
         self.icon = None
+        self.background_process = None
+        self.services_running = False
         
-    def create_icon_image(self):
+    def create_icon_image(self, color='blue'):
         """إنشاء صورة الأيقونة"""
         # إنشاء صورة بسيطة 64x64
-        image = Image.new('RGB', (64, 64), color='blue')
+        image = Image.new('RGB', (64, 64), color=color)
         draw = ImageDraw.Draw(image)
         
         # رسم دائرة بسيطة
         draw.ellipse([16, 16, 48, 48], fill='white')
-        draw.ellipse([20, 20, 44, 44], fill='blue')
+        draw.ellipse([20, 20, 44, 44], fill=color)
+        
+        # إضافة رمز صغير للإشارة للحالة
+        if self.services_running:
+            draw.rectangle([28, 28, 36, 36], fill='green')  # نقطة خضراء عند التشغيل
+        else:
+            draw.rectangle([28, 28, 36, 36], fill='red')    # نقطة حمراء عند التوقف
         
         return image
         
-    def get_service_status(self):
-        """الحصول على حالة الخدمة"""
+    def check_service_status(self):
+        """فحص حالة الخدمة"""
         try:
             response = requests.get(f"{self.base_url}/status", timeout=2)
-            return response.json()
+            if response.status_code == 200:
+                self.services_running = True
+                return response.json()
         except:
-            return None
-            
-    def start_services(self, icon, item):
-        """بدء تشغيل الخدمات"""
+            self.services_running = False
+        return None
+    
+    def start_background_service(self):
+        """بدء الخدمة الخلفية"""
         try:
-            requests.post(f"{self.base_url}/start", timeout=5)
-            self.update_menu()
+            if self.background_process and self.background_process.poll() is None:
+                print("✅ الخدمة الخلفية تعمل بالفعل")
+                return True
+                
+            print("🚀 بدء الخدمة الخلفية...")
+            self.background_process = subprocess.Popen(
+                [sys.executable, 'background_service.py', 'start'],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                creationflags=subprocess.CREATE_NO_WINDOW
+            )
+            
+            # انتظار حتى تبدأ الخدمة
+            for i in range(10):
+                time.sleep(1)
+                if self.check_service_status():
+                    print("✅ تم بدء الخدمة الخلفية بنجاح")
+                    self.services_running = True
+                    return True
+            
+            print("⚠️ بدأت الخدمة ولكنها لم تستجب بعد")
+            return False
+            
         except Exception as e:
-            print(f"فشل في بدء الخدمات: {e}")
+            print(f"❌ فشل في بدء الخدمة الخلفية: {e}")
+            return False
             
-    def stop_services(self, icon, item):
-        """إيقاف الخدمات"""
+    def stop_background_service(self):
+        """إيقاف الخدمة الخلفية"""
         try:
-            requests.post(f"{self.base_url}/stop", timeout=5)
-            self.update_menu()
+            if self.background_process:
+                # محاولة إيقاف نظيف عبر HTTP
+                try:
+                    requests.post(f"{self.base_url}/stop", timeout=5)
+                    time.sleep(2)
+                except:
+                    pass
+                
+                # إجبار الإيقاف إذا لزم
+                if self.background_process.poll() is None:
+                    self.background_process.terminate()
+                    self.background_process.wait(timeout=5)
+                
+                self.background_process = None
+                self.services_running = False
+                print("✅ تم إيقاف الخدمة الخلفية")
+                return True
+            else:
+                print("ℹ️ لا توجد خدمة خلفية قيد التشغيل")
+                return True
+                
         except Exception as e:
-            print(f"فشل في إيقاف الخدمات: {e}")
+            print(f"❌ فشل في إيقاف الخدمة الخلفية: {e}")
+            return False
             
-    def show_ui(self, icon, item):
+    def start_services(self, icon=None, item=None):
+        """بدء تشغيل الخدمات"""
+        print("🔧 بدء جميع الخدمات...")
+        success = self.start_background_service()
+        if success:
+            self.update_icon_menu()
+            print("✅ تم بدء جميع الخدمات")
+        else:
+            print("❌ فشل في بدء الخدمات")
+        
+    def stop_services(self, icon=None, item=None):
+        """إيقاف الخدمات"""
+        print("🛑 إيقاف جميع الخدمات...")
+        success = self.stop_background_service()
+        if success:
+            self.update_icon_menu()
+            print("✅ تم إيقاف جميع الخدمات")
+        else:
+            print("❌ فشل في إيقاف الخدمات")
+            
+    def show_ui(self, icon=None, item=None):
         """إظهار الواجهة التفاعلية"""
         try:
-            requests.post(f"{self.base_url}/show-ui", timeout=5)
-            # فتح المتصفح
+            # بدء الخدمة أولاً إذا لم تكن مشغلة
+            if not self.services_running:
+                self.start_background_service()
+                time.sleep(3)
+            
+            # محاولة فتح الواجهة
             webbrowser.open('http://localhost:5173')
+            print("🌐 فتح الواجهة في المتصفح...")
         except Exception as e:
-            print(f"فشل في إظهار الواجهة: {e}")
+            print(f"❌ فشل في فتح الواجهة: {e}")
             
-    def hide_ui(self, icon, item):
-        """إخفاء الواجهة التفاعلية"""
+    def open_dashboard(self, icon=None, item=None):
+        """فتح لوحة التحكم"""
         try:
-            requests.post(f"{self.base_url}/hide-ui", timeout=5)
+            webbrowser.open('http://localhost:5173/dashboard')
+            print("📊 فتح لوحة التحكم...")
         except Exception as e:
-            print(f"فشل في إخفاء الواجهة: {e}")
+            print(f"❌ فشل في فتح لوحة التحكم: {e}")
             
-    def open_dashboard(self, icon, item):
-        """فتح لوحة التحكم"""
-        webbrowser.open('http://localhost:5173/dashboard')
+    def open_web_interface(self, icon=None, item=None):
+        """فتح واجهة الويب"""
+        try:
+            webbrowser.open('http://localhost:PORT')
+            print("🖥️ فتح واجهة المهام...")
+        except Exception as e:
+            print(f"❌ فشل في فتح واجهة المهام: {e}")
         
-    def show_status(self, icon, item):
+    def show_status(self, icon=None, item=None):
         """إظهار حالة النظام"""
-        status = self.get_service_status()
+        status = self.check_service_status()
         if status:
-            status_text = f"حالة النظام: {status['status']}\n"
-            status_text += f"الخدمات النشطة: {len([s for s in status['services'].values() if s == 'running'])}\n"
-            status_text += f"وقت التشغيل: {int(status['uptime'])} ثانية"
+            status_text = f"✅ حالة النظام: {status.get('status', 'unknown')}\n"
+            status_text += f"📊 الخدمات النشطة: {len([s for s in status.get('services', {}).values() if s == 'running'])}\n"
+            status_text += f"⏱️ وقت التشغيل: {int(status.get('uptime', 0))} ثانية"
             print(status_text)
         else:
-            print("❌ لا يمكن الوصول للخدمة")
+            print("❌ الخدمات غير نشطة - استخدم 'بدء الخدمات' لتشغيلها")
+            
+    def show_system_info(self, icon=None, item=None):
+        """عرض معلومات النظام"""
+        try:
+            import psutil
+            cpu = psutil.cpu_percent(interval=1)
+            memory = psutil.virtual_memory()
             
-    def quit_app(self, icon, item):
+            info_text = f"⚡ استخدام المعالج: {cpu}%\n"
+            info_text += f"💾 استخدام الذاكرة: {memory.percent}%\n"
+            info_text += f"📡 الخدمات: {'🟢 نشطة' if self.services_running else '🔴 متوقفة'}"
+            print(info_text)
+        except Exception as e:
+            print(f"❌ فشل في الحصول على معلومات النظام: {e}")
+            
+    def restart_services(self, icon=None, item=None):
+        """إعادة تشغيل الخدمات"""
+        print("🔄 إعادة تشغيل الخدمات...")
+        self.stop_services()
+        time.sleep(2)
+        self.start_services()
+        
+    def quit_app(self, icon=None, item=None):
         """إنهاء التطبيق"""
-        self.stop_services(icon, item)
-        icon.stop()
+        print("🛑 إيقاف النظام...")
+        self.stop_services()
+        if icon:
+            icon.stop()
+        print("✅ تم إنهاء الت��بيق")
+        os._exit(0)
         
-    def update_menu(self):
+    def dummy_action(self, icon=None, item=None):
+        """إجراء افتراضي للفواصل"""
+        pass
+        
+    def update_icon_menu(self):
         """تحديث قائمة الأيقونة"""
         if self.icon:
-            status = self.get_service_status()
-            is_running = status and status['status'] == 'running'
+            # تحديث حالة الخدمات
+            self.check_service_status()
+            
+            # تحديث لون الأيقونة
+            icon_color = 'green' if self.services_running else 'red'
+            self.icon.icon = self.create_icon_image(icon_color)
             
             menu = pystray.Menu(
-                item('حالة النظام', self.show_status),
-                item('---'),
-                item('إظهار الواجهة', self.show_ui),
-                item('إخفاء الواجهة', self.hide_ui),
-                item('لوحة التحكم', self.open_dashboard),
-                item('---'),
-                item('بدء الخدمات', self.start_services, enabled=not is_running),
-                item('إيقاف الخدمات', self.stop_services, enabled=is_running),
-                item('---'),
-                item('إنهاء', self.quit_app)
+                item(f'الحالة: {"🟢 نشط" if self.services_running else "🔴 متوقف"}', self.dummy_action, enabled=False),
+                item('---', self.dummy_action),
+                item('📊 حالة النظام', self.show_status),
+                item('💻 معلومات النظام', self.show_system_info),
+                item('---', self.dummy_action),
+                item('🖥️ فتح الواجهة الرئيسية', self.show_ui),
+                item('📈 لوحة التحكم', self.open_dashboard),
+                item('⚙️ واجهة المهام', self.open_web_interface),
+                item('---', self.dummy_action),
+                item('🚀 بدء الخدمات', self.start_services, enabled=not self.services_running),
+                item('🛑 إيقاف الخدمات', self.stop_services, enabled=self.services_running),
+                item('🔄 إعادة التشغيل', self.restart_services),
+                item('---', self.dummy_action),
+                item('❌ إنهاء', self.quit_app)
             )
             
             self.icon.menu = menu
             
     def create_menu(self):
         """إنشاء قائمة الأيقونة"""
+        # فحص الحالة الأولية
+        self.check_service_status()
+        
         return pystray.Menu(
-            item('حالة النظام', self.show_status),
-            item('---'),
-            item('إظهار الواجهة', self.show_ui),
-            item('إخفاء الواجهة', self.hide_ui),
-            item('لوحة التحكم', self.open_dashboard),
-            item('---'),
-            item('بدء الخدمات', self.start_services),
-            item('إيقاف الخدمات', self.stop_services),
-            item('---'),
-            item('إنهاء', self.quit_app)
+            item(f'الحالة: {"🟢 نشط" if self.services_running else "🔴 متوقف"}', self.dummy_action, enabled=False),
+            item('---', self.dummy_action),
+            item('📊 حالة النظام', self.show_status),
+            item('💻 معلومات النظام', self.show_system_info),
+            item('---', self.dummy_action),
+            item('🖥️ فتح الواجهة الرئيسية', self.show_ui),
+            item('📈 لوحة التحكم', self.open_dashboard),
+            item('⚙️ واجهة المهام', self.open_web_interface),
+            item('---', self.dummy_action),
+            item('🚀 بدء الخدمات', self.start_services, enabled=not self.services_running),
+            item('🛑 إيقاف الخدمات', self.stop_services, enabled=self.services_running),
+            item('🔄 إعادة التشغيل', self.restart_services),
+            item('---', self.dummy_action),
+            item('❌ إنهاء', self.quit_app)
         )
         
     def run(self):
         """تشغيل أيقونة شريط النظام"""
         if not TRAY_AVAILABLE:
             print("❌ مكتبة pystray غير متوفرة")
-            return
+            print("💡 جرب: pip install pystray Pillow")
+            return False
             
-        # إنشاء الأيقونة
-        image = self.create_icon_image()
-        menu = self.create_menu()
-        
-        self.icon = pystray.Icon(
-            "نظام توزيع المهام",
-            image,
-            menu=menu
-        )
-        
-        # تحديث دوري للقائمة
-        def update_loop():
-            import time
-            while True:
-                time.sleep(5)
-                if self.icon and hasattr(self.icon, '_running') and self.icon._running:
-                    self.update_menu()
-                else:
-                    break
-                    
-        update_thread = threading.Thread(target=update_loop, daemon=True)
-        update_thread.start()
-        
-        print("🖱️ تشغيل أيقونة شريط النظام...")
-        self.icon.run()
+        try:
+            # إنشاء الأيقونة
+            icon_color = 'green' if self.services_running else 'red'
+            image = self.create_icon_image(icon_color)
+            menu = self.create_menu()
+            
+            self.icon = pystray.Icon(
+                "نظام توزيع المهام",
+                image,
+                menu=menu
+            )
+            
+            # تحديث دوري للقائمة
+            def update_loop():
+                while True:
+                    time.sleep(10)  # تحديث كل 10 ثواني
+                    if self.icon:
+                        try:
+                            self.update_icon_menu()
+                        except:
+                            break
+            
+            update_thread = threading.Thread(target=update_loop, daemon=True)
+            update_thread.start()
+            
+            print("🖱️ تشغيل أيقونة شريط النظام...")
+            print("💡 انقر بزر الماوس الأيمن على الأيقونة للخيارات")
+            self.icon.run()
+            return True
+            
+        except Exception as e:
+            print(f"❌ فشل في تشغيل أيقونة النظام: {e}")
+            return False
 
 def main():
+    print("🚀 بدء نظام توزيع المهام...")
     controller = SystemTrayController()
-    controller.run()
+    
+    # بدء الخدمات تلقائياً عند التشغيل (اختياري)
+    # controller.start_services()
+    
+    success = controller.run()
+    if not success:
+        print("❌ فشل في تشغيل واجهة النظام")
+        input("اضغط Enter للإغلاق...")
 
 if __name__ == "__main__":
     main()