Upload 66 files

DeviceManager.py

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

README_FIXES.md

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

auto_offload.py

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

autostart_config.py

@@ -2,6 +2,7 @@ import json
 import os
 import platform
 from pathlib import Path
+from peer_discovery import PORT
 
 class AutoStartManager:
     def __init__(self, app_name="DistributedTaskSystem"):

background_service.py

@@ -16,6 +16,7 @@ from pathlib import Path
 from flask import Flask, jsonify, request
 import json
 from datetime import datetime
+from peer_discovery import PORT
 
 class BackgroundService:
     def __init__(self):

central_manager.py

@@ -8,6 +8,7 @@ from typing import Dict, List
 import requests
 from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
+from peer_discovery import PORT
 
 # ---- إعداد FastAPI ----------------------------------------------------------
 app = FastAPI(title="Central Task Manager")
@@ -16,7 +17,7 @@ app = FastAPI(title="Central Task Manager")
 
 class RegisterRequest(BaseModel):
     """تسجيل أو تجديد ظهور العقدة."""
-    url: str          # مثلاً: "http://203.0.113.45:7520/run"
+    url: str          # مثلاً: "http://203.0.113.45:PORT/run"
     load: float = 0.0 # نسبة تحميل العقدة (0.0 - 1.0)، اختياري
 
 class TaskRequest(BaseModel):

config.py

@@ -1,10 +1,7 @@
-# config.py
+# config.py — نقطة مركزية لإعدادات المشروع
+import os, random
 
-OPENAI_API_KEY = "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"
-
-DEFAULT_LANGUAGE = "ar"
-DEFAULT_MODEL = "gpt-4"
-SYSTEM_PROMPT = """
-أنت مساعد ذكاء اصطناعي يتحكم به المستخدم عبر أوامر صوتية وكتابية، 
-يجب أن تستجيب بسرعة، وبدقة، وتتعلم من التعليمات الجديدة.
-"""
+# مصدر الحقيقة الوحيد لمنفذ الخدمة
+PORT = int(os.getenv("CPU_PORT", os.getenv("PORT", "0")))
+if PORT == 0:
+    PORT = random.randint(5000, 9999)

dashboard.py

@@ -1,55 +1,60 @@
-# dashboard.py
-from flask import Flask, render_template, jsonify
-from peer_discovery import discover_peers
-import threading
-import time
-from typing import List, Dict
 import logging
+import socket
+import threading
+import psutil
+import GPUtil
+from flask import Flask, render_template
+from flask_socketio import SocketIO, emit
+from peer_discovery import PEERS
+from peer_discovery import PORT
 
-app = Flask(__name__)
-app.logger.setLevel(logging.INFO)
 
-# تهيئة قائمة الأقران
-current_peers: Dict[str, List[Dict[str, str]]] = {"local": [], "external": []}
+logging.basicConfig(level=logging.INFO)
 
-def update_peers_loop() -> None:
-    """حلقة تحديث قائمة الأقران بشكل دوري"""
-    global current_peers
+app = Flask(__name__)
+socketio = SocketIO(app, cors_allowed_origins="*")
+
+node_id = socket.gethostname()
+connected_peers_data = {}
+
+# ─────────────── جمع بيانات الحمل ───────────────
+def get_system_status():
+    cpu = psutil.cpu_percent()
+    ram = psutil.virtual_memory().percent
+    gpu_load = 0
+    try:
+        gpus = GPUtil.getGPUs()
+        if gpus:
+            gpu_load = gpus[0].load * 100
+    except:
+        pass
+    return {"cpu": cpu, "ram": ram, "gpu": gpu_load}
+
+# ─────────────── إرسال التحديثات ───────────────
+def broadcast_status():
     while True:
-        try:
-            new_peers = discover_peers()
-            current_peers = new_peers
-            total_peers = len(new_peers["local"]) + len(new_peers["external"])
-            app.logger.info(f"تم تحديث قائمة الأقران: {total_peers} جهاز")
-        except Exception as e:
-            app.logger.error(f"خطأ في اكتشاف الأقران: {str(e)}")
-        time.sleep(10)
+        status = get_system_status()
+        socketio.emit("status_update", {node_id: status}, broadcast=True)
+        socketio.sleep(5)
 
+# ─────────────── صفحة الواجهة ───────────────
 @app.route("/")
-def dashboard() -> str:
-    """عرض لوحة التحكم الرئيسية"""
-    total_peers = len(current_peers["local"]) + len(current_peers["external"])
-    return render_template("dashboard.html",
-                           peers_count=total_peers,
-                           last_update=time.strftime("%Y-%m-%d %H:%M:%S"))
-
-@app.route("/api/peers")
-def get_peers() -> dict:
-    """واجهة API للحصول على قائمة الأقران"""
-    total_peers = len(current_peers["local"]) + len(current_peers["external"])
-    return jsonify({
-        "peers": current_peers,
-        "count": total_peers,
-        "status": "success"
-    })
-
-def start_background_thread() -> None:
-    """بدء خيط الخلفية لتحديث الأقران"""
-    thread = threading.Thread(target=update_peers_loop)
-    thread.daemon = True
-    thread.start()
+def index():
+    return render_template("dashboard.html", peers=connected_peers_data)
 
-if __name__ == "__main__":
-    start_background_thread()
-    app.run(host="0.0.0.0", port=7530, debug=False)
+# ─────────────── استقبال تحديثات الحالة ───────────────
+@socketio.on("status_update")
+def handle_status_update(data):
+    connected_peers_data.update(data)
+    emit("update_peers", connected_peers_data, broadcast=True)
+
+# ─────────────── دردشة ───────────────
+@socketio.on("send_message")
+def handle_message(data):
+    emit("receive_message", data, broadcast=True)
 
+# ─────────────── تشغيل ───────────────
+if __name__ == "__main__":
+    threading.Thread(target=broadcast_status).start()
+    logging.info(f"🚀 تشغيل Dashboard على {node_id}")
+    socketio.run(app, host="0.0.0.0", port=7000)

distributed_executor.py

@@ -1,15 +1,97 @@
 import threading
 import queue
 import time
-import json
 from typing import Callable, Dict, List
 import socket
 from zeroconf import Zeroconf, ServiceBrowser, ServiceInfo
 import logging
 import requests
+import subprocess
+import psutil
+import GPUtil
+from processor_manager import ResourceMonitor
+from peer_discovery import PORT
+
 
 logging.basicConfig(level=logging.INFO)
 
+# ─────────────── Device Manager عام ───────────────
+class DeviceManager:
+    def __init__(self):
+        self.devices = {
+            "GPU": self._detect_gpus(),
+            "DSP": self._detect_dsps(),
+            "NIC": self._detect_nics(),
+            "STORAGE": self._detect_storage(),
+            "CAPTURE": self._detect_capture(),
+            "ACCELERATOR": self._detect_accelerators()
+        }
+
+    # اكتشاف الأجهزة
+    def _detect_gpus(self):
+        try:
+            return GPUtil.getGPUs()
+        except:
+            return []
+
+    def _detect_dsps(self):
+        try:
+            output = subprocess.check_output(["aplay", "-l"], stderr=subprocess.DEVNULL).decode()
+            return ["DSP_Audio"] if "card" in output.lower() else []
+        except:
+            return []
+
+    def _detect_nics(self):
+        try:
+            return list(psutil.net_if_addrs().keys())
+        except:
+            return []
+
+    def _detect_storage(self):
+        try:
+            output = subprocess.check_output(["lsblk", "-o", "NAME"], stderr=subprocess.DEVNULL).decode()
+            return output.split() if output else []
+        except:
+            return []
+
+    def _detect_capture(self):
+        try:
+            output = subprocess.check_output(["v4l2-ctl", "--list-devices"], stderr=subprocess.DEVNULL).decode()
+            return output.split(":")[0::2] if output else []
+        except:
+            return []
+
+    def _detect_accelerators(self):
+        # افتراضي: يمكن إضافة اكتشاف حقيقي مستقبلاً
+        return ["Accelerator_Device"]
+
+    # قياس الحمل
+    def get_device_load(self, device_type, index=0):
+        try:
+            if device_type == "GPU" and self.devices["GPU"]:
+                return self.devices["GPU"][index].load * 100
+            elif device_type == "DSP" and self.devices["DSP"]:
+                return 10  # افتراضي
+            elif device_type == "NIC" and self.devices["NIC"]:
+                return psutil.net_io_counters().bytes_sent / (1024 * 1024)  # MB sent كمثال
+            elif device_type == "STORAGE" and self.devices["STORAGE"]:
+                return psutil.disk_usage('/').percent
+            elif device_type == "CAPTURE" and self.devices["CAPTURE"]:
+                return 20  # افتراضي
+            elif device_type == "ACCELERATOR" and self.devices["ACCELERATOR"]:
+                return 15  # افتراضي
+            return 0
+        except:
+            return 0
+
+    # منطق الاستقبال/الإرسال
+    def can_receive(self, device_type, index=0):
+        return self.get_device_load(device_type, index) <= 30
+
+    def should_offload(self, device_type, index=0):
+        return self.get_device_load(device_type, index) >= 70
+
+# ─────────────── Peer Registry ───────────────
 class PeerRegistry:
     def __init__(self):
         self._peers = {}
@@ -60,7 +142,7 @@ class PeerRegistry:
                 self.add_service(zc, type_, name)
 
             def remove_service(self, zc, type_, name):
-                pass  # يمكن تحسينه لاحقًا
+                pass
 
         listener = Listener()
         ServiceBrowser(self._zeroconf, "_tasknode._tcp.local.", listener)
@@ -78,7 +160,7 @@ class PeerRegistry:
             s.close()
         return ip
 
-
+# ─────────────── Distributed Executor ───────────────
 class DistributedExecutor:
     def __init__(self, shared_secret: str):
         self.peer_registry = PeerRegistry()
@@ -86,6 +168,7 @@ class DistributedExecutor:
         self.task_queue = queue.PriorityQueue()
         self.result_cache = {}
         self.available_peers = []
+        self.devices = DeviceManager()
         self._init_peer_discovery()
 
     def _init_peer_discovery(self):
@@ -97,7 +180,26 @@ class DistributedExecutor:
 
         threading.Thread(target=discovery_loop, daemon=True).start()
 
-    def submit(self, task_func: Callable, *args, **kwargs):
+    def submit(self, task_func: Callable, *args, task_type=None, **kwargs):
+        monitor = ResourceMonitor().current_load()
+        avg_cpu = monitor["average"]["cpu"]
+        avg_mem = monitor["average"]["mem_percent"] if "mem_percent" in monitor["average"] else 0
+
+        # تحديد نوع الجهاز
+        device_type = task_type.upper() if task_type else "CPU"
+
+        # فحص الحمل
+        if (avg_cpu > 0.6 or avg_mem > 85 or self.devices.should_offload(device_type)):
+            logging.info(f"⚠️ الحمل مرتفع على {device_type} - إرسال المهمة للأقران")
+            self._offload_task(task_func, *args, **kwargs)
+        elif (avg_cpu <= 0.3 and self.devices.can_receive(device_type)):
+            logging.info(f"✅ الحمل منخفض على {device_type} - تنفيذ المهمة محلياً")
+            return task_func(*args, **kwargs)
+        else:
+            logging.info(f"ℹ️ الحمل متوسط على {device_type} - تنفيذ المهمة محلياً")
+            return task_func(*args, **kwargs)
+
+    def _offload_task(self, task_func: Callable, *args, **kwargs):
         task_id = f"{task_func.__name__}_{time.time()}"
 
         task = {
@@ -122,6 +224,7 @@ class DistributedExecutor:
             self._send_to_peer(peer, task)
         else:
             logging.warning("⚠️ لا توجد أجهزة متاحة - سيتم تنفيذ المهمة محلياً")
+            task_func(*args, **kwargs)
 
     def _is_local_ip(self, ip: str) -> bool:
         return (
@@ -142,14 +245,13 @@ class DistributedExecutor:
             logging.error(f"❌ فشل إرسال المهمة لـ {peer['node_id']}: {e}")
             return None
 
-
+# ─────────────── تشغيل رئيسي ───────────────
 if __name__ == "__main__":
     executor = DistributedExecutor("my_secret_key")
-    executor.peer_registry.register_service("node1", 7520, load=0.1)
+    executor.peer_registry.register_service("node1", PORT, load=0.1)
     print("✅ نظام توزيع المهام جاهز...")
 
     def example_task(x):
         return x * x
 
-    executor.submit(example_task, 5)
-
+    executor.submit(example_task, 5, task_type="GPU")

dts_cli.py

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

enhanced_assistant.py

@@ -9,6 +9,7 @@ from PIL import Image
 from io import BytesIO
 import re
 from datetime import datetime
+from peer_discovery import PORT
 
 class EnhancedNoraAssistant:
     def __init__(self):

external_server.py

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

gui.py

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

internet_scanner.py

@@ -8,6 +8,7 @@ import time
 import socket
 from concurrent.futures import ThreadPoolExecutor, as_completed
 import logging
+from peer_discovery import PORT
 
 class InternetScanner:
     def __init__(self):
@@ -19,7 +20,7 @@ class InternetScanner:
             "208.67.222.0/24", # OpenDNS range
         ]
         
-    def scan_ip_range(self, ip_range: str, port: int = 7520):
+    def scan_ip_range(self, ip_range: str, port: int = PORT):
         """مسح نطاق IP للبحث عن خوادم DTS"""
         import ipaddress
         
@@ -48,7 +49,7 @@ class InternetScanner:
             logging.error(f"خطأ في مسح النطاق {ip_range}: {e}")
             return []
     
-    def check_dts_node(self, ip: str, port: int = 7520) -> str:
+    def check_dts_node(self, ip: str, port: int = PORT) -> str:
         """فحص IP معين للتأكد من وجود خادم DTS مع المشروع"""
         try:
             # فحص صفحة الصحة العامة
@@ -94,7 +95,7 @@ class InternetScanner:
             # البحث في GitHub عن مشاريع DTS
             github_api = "https://api.github.com/search/repositories"
             params = {
-                "q": "distributed task system port:7520",
+                "q": "distributed task system port:PORT",
                 "sort": "updated",
                 "per_page": 10
             }
@@ -122,7 +123,7 @@ class InternetScanner:
             try:
                 # التحقق من صحة IP
                 socket.inet_aton(ip)
-                peer_url = f"http://{ip}:7520/run"
+                peer_url = f"http://{ip}:PORT/run"
                 
                 # فحص سريع
                 if self.check_dts_node(ip):

launcher.py

@@ -11,6 +11,7 @@ import subprocess
 import argparse
 import time
 from pathlib import Path
+from peer_discovery import PORT
 
 def check_requirements():
     """فحص المتطلبات والاعتماديات"""

live_streaming.py

@@ -13,6 +13,7 @@ from datetime import datetime
 from processor_manager import should_offload
 from remote_executor import execute_remotely
 from functools import wraps
+from peer_discovery import PORT
 
 logging.basicConfig(level=logging.INFO)
 

load_balancer.py

@@ -1,5 +1,6 @@
 # load_balancer.py
 import peer_discovery, requests, time, smart_tasks, psutil, socket
+from peer_discovery import PORT
 
 def send(peer, func, *args, **kw):
     try:

node_client.py

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

package.json

@@ -42,9 +42,7 @@
     "@radix-ui/react-toggle-group": "^1.1.3",
     "@radix-ui/react-tooltip": "^1.2.0",
     "@tanstack/react-query": "^5.60.5",
-    "@types/bcryptjs": "^2.4.6",
-    "@types/jsonwebtoken": "^9.0.9",
-    "bcryptjs": "^3.0.2",
+    "bonjour-service": "^1.3.0",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "cmdk": "^1.1.1",
@@ -56,21 +54,17 @@
     "express": "^4.21.2",
     "express-session": "^1.18.1",
     "framer-motion": "^11.13.1",
-    "i18next": "^25.2.0",
     "input-otp": "^1.4.2",
-    "jsonwebtoken": "^9.0.2",
     "lucide-react": "^0.453.0",
     "memorystore": "^1.6.7",
+    "nanoid": "^5.1.5",
     "next-themes": "^0.4.6",
-    "node-cron": "^4.0.5",
-    "nodemailer": "^7.0.3",
     "passport": "^0.7.0",
     "passport-local": "^1.0.0",
     "react": "^18.3.1",
     "react-day-picker": "^8.10.1",
     "react-dom": "^18.3.1",
     "react-hook-form": "^7.55.0",
-    "react-i18next": "^15.5.1",
     "react-icons": "^5.4.0",
     "react-resizable-panels": "^2.1.7",
     "recharts": "^2.15.2",
@@ -84,7 +78,7 @@
     "zod-validation-error": "^3.4.0"
   },
   "devDependencies": {
-    "@replit/vite-plugin-cartographer": "^0.2.0",
+    "@replit/vite-plugin-cartographer": "^0.2.7",
     "@replit/vite-plugin-runtime-error-modal": "^0.0.3",
     "@tailwindcss/typography": "^0.5.15",
     "@tailwindcss/vite": "^4.1.3",
@@ -100,12 +94,14 @@
     "@vitejs/plugin-react": "^4.3.2",
     "autoprefixer": "^10.4.20",
     "drizzle-kit": "^0.30.4",
+    "electron": "^37.1.0",
+    "electron-builder": "^26.0.12",
     "esbuild": "^0.25.0",
     "postcss": "^8.4.47",
     "tailwindcss": "^3.4.17",
     "tsx": "^4.19.1",
     "typescript": "5.6.3",
-    "vite": "^5.4.14"
+    "vite": "^5.4.19"
   },
   "optionalDependencies": {
     "bufferutil": "^4.0.8"

peer_discovery.py

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

peer_registry.py

@@ -1,6 +1,7 @@
 import socket
 import time
 from zeroconf import Zeroconf, ServiceBrowser, ServiceInfo
+from peer_discovery import PORT
 
 class Listener:
     def __init__(self):
@@ -55,7 +56,7 @@ def discover_peers(timeout=2):
 
 if __name__ == "__main__":
     local_ip = socket.gethostbyname(socket.gethostname())
-    port = 7520
+    port = PORT
 
     zc = register_service(local_ip, port, load=0.1)
 

peer_server.py

@@ -5,8 +5,20 @@ import psutil
 import smart_tasks
 import time
 import socket
-import peer_discovery  # إذا كان يستخدم لاحقًا
-
+from peer_discovery import PORT
+from flask import Flask
+app = Flask(__name__)
+@app.route("/run", methods=["POST"])
+def run_task():
+    try:
+        data = request.get_json()
+        print("🔹 البيانات المستلمة:", data)
+        count = data.get("count", 100)
+        ...
+        return jsonify(result)
+    except Exception as e:
+        print("❌ خطأ أثناء التنفيذ:", e)
+        return jsonify({"error": str(e)}), 500
 app = Flask(__name__)  # إنشاء التطبيق
 
 @app.route("/cpu")
@@ -33,5 +45,5 @@ def run():
         return jsonify(error=str(e)), 500
 
 if __name__ == "__main__":  # التصحيح هنا
-    app.run(host="0.0.0.0", port=7520)
+    app.run(host="0.0.0.0", port=PORT)
 

quick_connection_test.py

@@ -13,7 +13,7 @@ def test_connection():
     
     # 1. فحص الخادم المحلي
     try:
-        response = requests.get("http://localhost:7520/health", timeout=3)
+        response = requests.get("http://localhost:PORT/health", timeout=3)
         if response.status_code == 200:
             print("✅ الخادم المحلي يعمل")
         else:

ram_manager.py

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

remote_executor.py

@@ -12,11 +12,12 @@ from typing import Any
 
 # قائمة الأقران (URLs) المستخرجة من peer_discovery
 from peer_discovery import PEERS
+from peer_discovery import PORT
 
 # عنوان افتراضي احتياطي (يمكن تغييره بمتغير بيئي REMOTE_SERVER)
 FALLBACK_SERVER = os.getenv(
     "REMOTE_SERVER",
-    "http://89.111.171.92:7520/run"
+    "http://89.111.171.92:PORT/run"
 )
 
 # محاولة استيراد SecurityManager (اختياري)

rpc_server.py

@@ -9,6 +9,7 @@ from flask import Flask, request, jsonify
 import smart_tasks  # «your_tasks» تمّ استيراده تحت هذا الاسم فى main.py
 import logging, json
 from security_layer import SecurityManager
+from peer_discovery import PORT
 
 SECURITY = SecurityManager("my_shared_secret_123")
 
@@ -69,5 +70,5 @@ def run():
 
 # ------------------------------------------------------------------
 if name == "main":
-    # تأكد أن المنفذ 7520 مفتوح
-    app.run(host="0.0.0.0", port=7520)
+    # تأكد أن المنفذ PORT مفتوح
+    app.run(host="0.0.0.0", port=PORT)

security_layer.py

@@ -9,6 +9,7 @@ from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
 from cryptography.fernet import Fernet
 import os, base64, json
 from typing import Dict
+from peer_discovery import PORT
 
 
 class SecurityManager:

server.py

@@ -4,6 +4,7 @@ import json
 from your_tasks import *
 from project_identifier import create_project_endpoint, get_project_info
 import logging
+from peer_discovery import PORT
 
 app = Flask(__name__)
 CORS(app)
@@ -21,7 +22,7 @@ def multiply():
 
 @app.route('/health', methods=['GET'])
 def health_check():
-    return jsonify({"status": "healthy", "port": 7520})
+    return jsonify({"status": "healthy", "port": PORT})
 
 @app.route('/project_info', methods=['GET'])
 def project_info():
@@ -29,4 +30,4 @@ def project_info():
 
 if __name__ == "__main__":
     # هذا العنوان يسمح بالاستماع على IP خارجي لتلقي الاتصالات من الإنترنت
-    app.run(host="0.0.0.0", port=7520)
+    app.run(host="0.0.0.0", port=PORT)

smart_tasks.py

@@ -1,6 +1,7 @@
 import math
 import numpy as np
 import time
+from peer_discovery import PORT
 
 def prime_calculation(n: int):
     """ترجع قائمة الأعداد الأوليّة حتى n مع عددها"""
@@ -135,4 +136,4 @@ def game_ai_processing(ai_agents_count, decision_complexity, game_state_size):
         "total_operations": total_operations,
         "processing_time": time.time() - start_time,
         "server_processed": True
-    }
+    }

system_check.py

@@ -7,6 +7,7 @@ import requests
 import psutil
 import threading
 from offload_lib import discover_peers
+from peer_discovery import PORT
 
 def check_local_system():
     """فحص النظام المحلي"""
@@ -23,7 +24,7 @@ def check_server_running():
     """فحص إذا كان الخادم المحلي يعمل"""
     print("🌐 فحص الخادم المحلي...")
     try:
-        response = requests.get("http://localhost:7520/health", timeout=3)
+        response = requests.get("http://localhost:PORT/health", timeout=3)
         if response.status_code == 200:
             print("✅ الخادم المحلي يعمل بشكل صحيح")
             return True

system_tray.py

@@ -9,6 +9,7 @@ import threading
 import requests
 import webbrowser
 from pathlib import Path
+from peer_discovery import PORT
 
 try:
     import pystray

task_splitter.py

@@ -2,6 +2,7 @@
 from typing import Dict, Any, List
 import networkx as nx
 import hashlib
+from peer_discovery import PORT
 
 class TaskSplitter:
     def __init__(self):

test_distributed_system.py

@@ -9,6 +9,7 @@ import psutil
 import logging
 from offload_lib import discover_peers, matrix_multiply, prime_calculation, data_processing
 from your_tasks import complex_operation
+from peer_discovery import PORT
 
 # إعداد السجل
 logging.basicConfig(

test_monitor.py

@@ -7,6 +7,7 @@ import threading
 import psutil
 import signal
 import sys
+from peer_discovery import PORT
 
 class TestMonitor:
     def __init__(self):

video_processing.py

@@ -7,6 +7,7 @@ import logging
 from functools import wraps
 from processor_manager import should_offload
 from remote_executor import execute_remotely
+from peer_discovery import PORT
 
 logging.basicConfig(level=logging.INFO)
 

your_tasks.py

@@ -1,6 +1,7 @@
 import math
 import numpy as np
 from offload_lib import offload
+from peer_discovery import PORT
 
 # الدوال الأساسية (محليّة)
 def prime_calculation(n: int):