Update app.py

app.py

@@ -1,36 +1,19 @@
 """
-THE Z AI — Computer Mode Server v10 — SCREENSHOT RACE-CONDITION FIXED
-=======================================================================
-المشاكل التي تسبب "لم تصل لقطة شاشة" — وجدناها وأصلحناها:
-
-🐛 BUG 1 — Delta Suppression يكتم Screenshot المطلوبة صراحةً:
-   في v9، دالة shot() كانت تتحقق من hash الصورة السابقة وتُلغي الإرسال إذا
-   "لم تتغير الصورة" — لكن الـ HTML يطلب screenshot بشكل صريح ويستظهر وصولها
-   بمقارنة _pcLastFrameTs. إذا الشاشة لم تتغير (مثلاً بعد keyboard_hotkey)،
-   السيرفر يُلغي الإرسال → الـ HTML ينتظر إلى ما لا نهاية → "لم تصل لقطة شاشة".
-   الإصلاح: Delta suppression تنطبق على auto_shot فقط (الخلفية)، وليس على
-   طلبات screenshot الصريحة (action == "screenshot").
-
-🐛 BUG 2 — auto_shot كـ background task يتأخر أو يُلغى:
-   asyncio.create_task(shot_bg(...)) كانت تُنشئ task في الخلفية قد يتأخر تنفيذها
-   لأن asyncio يُجدولها لاحقاً — الـ HTML يطلب screenshot ثم ينتظر 12 ثانية
-   لكن الـ auto_shot قد لم يُرسل بعد بسبب تزاحم الـ tasks.
-   الإصلاح: الأوامر الصريحة (screenshot action) تُجيب فوراً بـ await، لا create_task.
-   فقط auto_shot الخلفي (بعد mouse_move مثلاً) يبقى كـ create_task.
-
-🐛 BUG 3 — Rate Limit 0.3s يمنع الرد الفوري:
-   الـ HTML يطلب screenshot ثم ينتظر — لكن السيرفر كان ينتظر 0.3 ثانية أولاً
-   بسبب rate limiting. مع تكدس الطلبات، التأخر يتراكم → timeout → "لم تصل".
-   الإصلاح: Rate limit تنطبق على auto_shot الخلفي فقط، لا على الطلبات الصريحة.
-
-✅ إصلاحات إضافية من v9 (تبقى):
-   - حذف --profile (كان يسبب "Firefox profile cannot be loaded")
-   - Xvfb واحد ثابت مشترك
-   - screenshot retry x3 إذا الصورة سوداء
-   - Heartbeat ping/pong كل 20 ثانية
-   - terminal semaphore(4)
-   - SafeSearch على كل URL
-   - تنظيف /tmp كل 5 دقائق
+THE Z AI — Computer Mode Server v11 — PER-USER ISOLATED DISPLAYS
+=================================================================
+كل مستخدم لديه:
+  ✅ Display Xvfb خاص (:100, :101, :102 ...)
+  ✅ متصفح Firefox معزول تماماً لا يتشارك مع أي مستخدم آخر
+  ✅ لقطات شاشة مستقلة — ما يراه مستخدم A لا يختلط بمستخدم B
+  ✅ تاريخ terminal مستقل لكل مستخدم
+  ✅ عند كل اتصال جديد للمستخدم: نفس الـ display (لا يُعاد إنشاء Xvfb)
+  ✅ عند طلب ريستارت / كمبيوتر جديد: Xvfb + Firefox يُعادان تماماً
+
+الفكرة:
+  - كل user_id (email) ↦ display رقم ثابت (مثلاً :100 للأول، :101 للثاني)
+  - إذا المستخدم يتصل مجدداً، نُعيد استخدام نفس الـ display الخاص به
+  - إذا طلب ريستارت، نقتل الـ Xvfb والمتصفح ونُعيد إنشاءهما
+  - إذا المستخدم جديد، نخصص له display جديد ونُشغّل Xvfb له
 """
 
 import asyncio
@@ -43,176 +26,285 @@ import re
 import subprocess
 import time
 import urllib.parse
+import threading
 
-from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect, Query
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse, HTMLResponse
 import uvicorn
 
 # ════════════════════════════════════════════════════════════════
-# ── الإعداد الأساسي ──────────────────────────────────────────
+# ── إعداد Display Pool ─────────────────────────────────────────
 # ════════════════════════════════════════════════════════════════
 
-# DISPLAY واحد ثابت — يُشغَّل مرة واحدة فقط
-SHARED_DISPLAY = os.environ.get("DISPLAY", ":99")
-os.environ["DISPLAY"] = SHARED_DISPLAY
+# بداية نطاق الـ displays الافتراضية (يمكن تغييره)
+DISPLAY_BASE = 100
+DISPLAY_MAX  = 200   # أقصى عدد مستخدمين متزامنين
 
-# semaphore للتحكم في عدد عمليات terminal المتوازية
-_terminal_sem = asyncio.Semaphore(4)
+_display_lock = threading.Lock()
 
-# ── تخزين الجلسات: session_id → {last_bg_shot_ts, last_bg_hash, browser_proc} ──
-_active_sessions: dict[int, dict] = {}
-_sessions_lock = asyncio.Lock()
+# user_id → display_info
+# display_info = {
+#   "display": ":101",
+#   "xvfb_proc": subprocess.Popen | None,
+#   "browser_proc": subprocess.Popen | None,
+#   "last_bg_shot_ts": float,
+#   "last_bg_hash": str,
+#   "active_ws": WebSocket | None,   # الاتصال الحالي لهذا المستخدم
+# }
+_user_displays: dict[str, dict] = {}
+_display_numbers: set[int] = set()  # أرقام الـ displays المستخدمة
+
+# semaphore للتحكم في عمليات terminal (global لكل السيرفر)
+_terminal_sem = asyncio.Semaphore(8)
 
 # ════════════════════════════════════════════════════════════════
-# ── إعداد Xvfb المشترك الثابت ────────────────────────────────
+# ── اكتشاف المتصفح ────────────────────────────────────────────
 # ════════════════════════════════════════════════════════════════
 
-_xvfb_proc: "subprocess.Popen | None" = None
+def _detect_browser() -> str:
+    for c in ["firefox", "firefox-esr", "chromium-browser", "chromium", "google-chrome"]:
+        r = subprocess.run(["which", c], capture_output=True, text=True)
+        if r.returncode == 0 and r.stdout.strip():
+            return c
+    return "firefox"
 
-def _ensure_xvfb() -> bool:
-    """
-    يتأكد أن Xvfb يعمل على SHARED_DISPLAY.
-    إذا كان يعمل بالفعل (من Docker أو systemd): لا يفعل شيئاً.
-    إذا لم يكن يعمل: يُشغّله ويُعيد True عند النجاح.
-    """
-    global _xvfb_proc
+BROWSER = _detect_browser()
+print(f"🌐 Browser: {BROWSER}")
+
+
+# ════════════════════════════════════════════════════════════════
+# ── Xvfb Management (per-display) ────────────────────────────
+# ════════════════════════════════════════════════════════════════
 
-    # تحقق أولاً: هل DISPLAY موجود بالفعل؟
+def _next_free_display() -> int:
+    """يجد رقم display حر غير مستخدم."""
+    used = _display_numbers.copy()
+    for n in range(DISPLAY_BASE, DISPLAY_MAX):
+        if n not in used:
+            return n
+    # إذا امتلأت القائمة — أعد استخدام أقدم display غير نشط
+    return DISPLAY_BASE
+
+
+def _start_xvfb(display: str) -> "subprocess.Popen | None":
+    """يُشغّل Xvfb على display محدد ويُعيد الـ Popen أو None."""
+    # تحقق أولاً: هل الـ display يعمل بالفعل؟
     try:
         r = subprocess.run(
-            ["xdpyinfo", "-display", SHARED_DISPLAY],
+            ["xdpyinfo", "-display", display],
             capture_output=True, timeout=3
         )
         if r.returncode == 0:
-            print(f"[xvfb] ✅ Display {SHARED_DISPLAY} already active (external)")
-            return True
-    except FileNotFoundError:
-        pass  # xdpyinfo غير متاح — سنكمل بدون تحقق
+            print(f"[xvfb] ✅ Display {display} already active")
+            return None  # يعمل بالفعل بدون Popen نشغّله
     except Exception:
         pass
 
-    # شغّل Xvfb
     try:
-        _xvfb_proc = subprocess.Popen(
-            ["Xvfb", SHARED_DISPLAY, "-screen", "0", "1920x1080x24",
+        proc = subprocess.Popen(
+            ["Xvfb", display, "-screen", "0", "1920x1080x24",
              "-nolisten", "tcp", "-ac"],
             stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
         )
-        # انتظر حتى يصبح جاهزاً (max 5 ثواني)
-        for _ in range(50):
+        # انتظر حتى يصبح جاهزاً (max 6 ثواني)
+        for _ in range(60):
             time.sleep(0.1)
             try:
                 r = subprocess.run(
-                    ["xdpyinfo", "-display", SHARED_DISPLAY],
+                    ["xdpyinfo", "-display", display],
                     capture_output=True, timeout=2
                 )
                 if r.returncode == 0:
-                    print(f"[xvfb] ✅ Xvfb started on {SHARED_DISPLAY}")
-                    return True
+                    print(f"[xvfb] ✅ Xvfb started on {display}")
+                    return proc
             except Exception:
                 continue
-        print(f"[xvfb] ⚠️ Xvfb may not be ready yet — continuing anyway")
-        return True
+        print(f"[xvfb] ⚠️ Xvfb may not be ready yet on {display}")
+        return proc
     except FileNotFoundError:
-        print(f"[xvfb] ❌ Xvfb binary not found — screenshots will fail")
-        return False
+        print(f"[xvfb] ❌ Xvfb binary not found")
+        return None
     except Exception as e:
-        print(f"[xvfb] ❌ Failed to start: {e}")
-        return False
+        print(f"[xvfb] ❌ Failed to start on {display}: {e}")
+        return None
 
-# اكتشاف المتصفح
-def _detect_browser() -> str:
-    for c in ["firefox", "firefox-esr", "chromium-browser", "chromium", "google-chrome"]:
-        r = subprocess.run(["which", c], capture_output=True, text=True)
-        if r.returncode == 0 and r.stdout.strip():
-            return c
-    return "firefox"
 
-BROWSER = _detect_browser()
-print(f"🌐 Browser: {BROWSER}")
+def _kill_proc(proc: "subprocess.Popen | None"):
+    """يقتل process بأمان."""
+    if not proc:
+        return
+    try:
+        proc.terminate()
+        proc.wait(timeout=3)
+    except Exception:
+        try:
+            proc.kill()
+        except Exception:
+            pass
+
+
+def _kill_display_processes(display: str):
+    """يقتل كل العمليات المرتبطة بـ display معين."""
+    env_d = {**os.environ, "DISPLAY": display}
+    # قتل المتصفح
+    for b in ["firefox", "firefox-esr", "chromium", "chrome"]:
+        try:
+            subprocess.run(
+                ["pkill", "-f", f"[{b[0]}]{b[1:]}.*{display}"],
+                timeout=3, capture_output=True
+            )
+        except Exception:
+            pass
+    # قتل Xvfb على هذا الـ display
+    try:
+        subprocess.run(
+            ["pkill", "-f", f"[X]vfb {display}"],
+            timeout=3, capture_output=True
+        )
+    except Exception:
+        pass
+    time.sleep(0.5)
+
 
 # ════════════════════════════════════════════════════════════════
-# ── إدارة الجلسات (Profile-based isolation) ─────────────────
+# ── Session Management (per user_id) ─────────────────────────
 # ════════════════════════════════════════════════════════════════
 
-async def create_session(ws: WebSocket) -> dict:
+async def get_or_create_user_session(user_id: str, ws: WebSocket) -> dict:
     """
-    ينشئ session بسيطة لهذا المستخدم.
-    لا profile منفصل — Firefox يعمل بـ --no-remote فقط للعزل.
+    يُعيد session المستخدم (أو يُنشئ واحدة جديدة إذا لم تكن موجودة).
+    كل user_id ← display خاص + Xvfb خاص.
     """
-    sid = id(ws)
-    sess = {
-        "id": sid,
-        "last_bg_shot_ts": 0.0,
-        "last_bg_hash": "",
-        "browser_proc": None,
-        "created": time.time(),
-    }
-    async with _sessions_lock:
-        _active_sessions[sid] = sess
-    print(f"[session] ✅ Created session {sid}")
-    return sess
-
-
-async def destroy_session(ws: WebSocket):
-    """يحرر موارد الجلسة عند انقطاع الاتصال."""
-    sid = id(ws)
-    async with _sessions_lock:
-        sess = _active_sessions.pop(sid, None)
-    if not sess:
-        return
+    with _display_lock:
+        if user_id in _user_displays:
+            sess = _user_displays[user_id]
+            # حدّث الـ WebSocket الحالي
+            sess["active_ws"] = ws
+            print(f"[session] 🔁 Reconnected user '{user_id}' on display {sess['display']}")
+            return sess
+
+        # مستخدم جديد — خصص له display
+        disp_num = _next_free_display()
+        _display_numbers.add(disp_num)
+        display = f":{disp_num}"
+
+        sess = {
+            "user_id": user_id,
+            "display": display,
+            "xvfb_proc": None,   # سيُشغَّل لاحقاً
+            "browser_proc": None,
+            "last_bg_shot_ts": 0.0,
+            "last_bg_hash": "",
+            "active_ws": ws,
+            "created": time.time(),
+        }
+        _user_displays[user_id] = sess
+        print(f"[session] ✅ New user '{user_id}' → display {display}")
+        return sess
+
+
+async def reset_user_computer(user_id: str) -> dict:
+    """
+    يُعيد ضبط الكمبيوتر الافتراضي للمستخدم:
+    يقتل Xvfb والمتصفح ويُشغّل Xvfb جديداً نظيفاً.
+    """
+    with _display_lock:
+        sess = _user_displays.get(user_id)
+        if not sess:
+            return {}
 
-    def _cleanup():
-        bp = sess.get("browser_proc")
-        if bp:
-            try:
-                bp.terminate()
-                bp.wait(timeout=3)
-            except Exception:
-                try:
-                    bp.kill()
-                except Exception:
-                    pass
+        display = sess["display"]
+        print(f"[reset] 🔄 Resetting computer for user '{user_id}' on {display}")
 
-    await asyncio.to_thread(_cleanup)
-    print(f"[session] 🗑️ Destroyed session {sid}")
+        # قتل المتصفح
+        _kill_proc(sess.get("browser_proc"))
+        sess["browser_proc"] = None
 
+        # قتل Xvfb
+        _kill_proc(sess.get("xvfb_proc"))
+        sess["xvfb_proc"] = None
 
-def get_browser_cmd(url: str = "") -> list:
-    """يبني أمر فتح المتصفح بدون profile — --no-remote يمنع التداخل."""
-    cmd = [BROWSER, "--no-remote"]
-    cmd.append(url if url else "about:blank")
-    return cmd
+        # تنظيف شامل لهذا الـ display
+        _kill_display_processes(display)
+
+        # تنظيف lock files Firefox
+        try:
+            subprocess.run(
+                "rm -f ~/.mozilla/firefox/*/lock ~/.mozilla/firefox/*/.parentlock 2>/dev/null",
+                shell=True, timeout=5, capture_output=True
+            )
+        except Exception:
+            pass
+
+    # تشغيل Xvfb جديد (خارج الـ lock لأن start_xvfb يستغرق وقتاً)
+    new_proc = await asyncio.to_thread(_start_xvfb, display)
+    with _display_lock:
+        if user_id in _user_displays:
+            _user_displays[user_id]["xvfb_proc"] = new_proc
+            _user_displays[user_id]["last_bg_shot_ts"] = 0.0
+            _user_displays[user_id]["last_bg_hash"] = ""
+
+    print(f"[reset] ✅ Computer reset done for '{user_id}' on {display}")
+    return _user_displays.get(user_id, {})
+
+
+async def ensure_xvfb_for_session(sess: dict):
+    """يتأكد أن Xvfb يعمل لهذا الـ session — يُشغّله إذا لم يكن كذلك."""
+    display = sess["display"]
+
+    # تحقق إذا كان يعمل بالفعل
+    try:
+        r = subprocess.run(
+            ["xdpyinfo", "-display", display],
+            capture_output=True, timeout=3
+        )
+        if r.returncode == 0:
+            return  # يعمل
+    except Exception:
+        pass
+
+    # شغّله
+    proc = await asyncio.to_thread(_start_xvfb, display)
+    with _display_lock:
+        if sess["user_id"] in _user_displays:
+            _user_displays[sess["user_id"]]["xvfb_proc"] = proc
+
+
+async def destroy_user_ws(user_id: str, ws: WebSocket):
+    """
+    يُزيل الـ WebSocket من الـ session عند انقطاع الاتصال.
+    لا يحذف الـ session نفسها — المستخدم يحتفظ بكمبيوتره.
+    """
+    with _display_lock:
+        sess = _user_displays.get(user_id)
+        if sess and sess.get("active_ws") is ws:
+            sess["active_ws"] = None
+    print(f"[session] 📴 User '{user_id}' disconnected (session kept)")
 
 
 # ════════════════════════════════════════════════════════════════
-# ── Screenshot Engine (Multi-method + Black Screen Check) ────
+# ── Screenshot Engine (per-display) ──────────────────────────
 # ════════════════════════════════════════════════════════════════
 
 def _is_black_screen(img) -> bool:
-    """
-    يكتشف ما إذا كانت الصورة سوداء تقريباً (Xvfb يعمل لكن لا شيء فيه).
-    يأخذ عينة من 100 pixel ويحسب متوسط الـ brightness.
-    """
     try:
         small = img.resize((100, 100))
         pixels = list(small.getdata())
         avg = sum(sum(p[:3]) for p in pixels) / (len(pixels) * 3 * 255)
-        return avg < 0.04  # أقل من 4% brightness = أسود فعلياً
+        return avg < 0.04
     except Exception:
         return False
 
 
-def _capture_raw() -> tuple:
-    """
-    يلتقط الشاشة بـ 4 طرق متسلسلة مع retry إذا الصورة سوداء.
-    يُعيد (PIL.Image | None, width, height).
-    """
+def _capture_raw(display: str) -> tuple:
+    """يلتقط الشاشة من display محدد."""
     from PIL import Image
-    env = {**os.environ, "DISPLAY": SHARED_DISPLAY}
+    env = {**os.environ, "DISPLAY": display}
     ts = int(time.time() * 1000)
-    tmp_base = f"/tmp/zss_{ts}"
+    # استخدم display number في اسم الملف لتفادي التعارض
+    disp_safe = display.replace(":", "")
+    tmp_base = f"/tmp/zss_{disp_safe}_{ts}"
     created_files = []
 
     def _try_load(path) -> tuple:
@@ -227,7 +319,7 @@ def _capture_raw() -> tuple:
                 return None, 0, 0
             return img, w, h
         except Exception as ex:
-            print(f"[cap] load error: {ex}")
+            print(f"[cap:{display}] load error: {ex}")
             return None, 0, 0
 
     def _cleanup_files():
@@ -238,66 +330,56 @@ def _capture_raw() -> tuple:
             except Exception:
                 pass
 
-    # نحاول 3 مرات إذا الصورة سوداء (مثلاً: Firefox لا يزال يتحمّل)
     for attempt in range(3):
         if attempt > 0:
             time.sleep(0.8)
-            print(f"[cap] retry attempt {attempt+1} (black screen)")
+            print(f"[cap:{display}] retry attempt {attempt+1} (black screen)")
         try:
-            # ── Method 1: scrot ──────────────────────────────
+            # Method 1: scrot
             p1 = f"{tmp_base}_a{attempt}_scrot.png"
             created_files.append(p1)
             try:
-                r = subprocess.run(
-                    ["scrot", "-q", "95", p1],
-                    env=env, timeout=8, capture_output=True
-                )
+                subprocess.run(["scrot", "-q", "95", p1],
+                    env=env, timeout=8, capture_output=True)
                 img, w, h = _try_load(p1)
                 if img and not _is_black_screen(img):
-                    print(f"[cap] ✅ scrot (attempt {attempt+1})")
                     return img, w, h
-                if img:
-                    print(f"[cap] scrot: black screen (attempt {attempt+1})")
             except Exception as e:
-                print(f"[cap] scrot: {e}")
+                print(f"[cap:{display}] scrot: {e}")
 
-            # ── Method 2: ImageMagick import ─────────────────
+            # Method 2: ImageMagick import
             p2 = f"{tmp_base}_a{attempt}_im.png"
             created_files.append(p2)
             try:
-                subprocess.run(
-                    ["import", "-window", "root", "-silent", p2],
-                    env=env, timeout=10, capture_output=True
-                )
+                subprocess.run(["import", "-window", "root", "-silent", p2],
+                    env=env, timeout=10, capture_output=True)
                 img, w, h = _try_load(p2)
                 if img and not _is_black_screen(img):
-                    print(f"[cap] ✅ import (attempt {attempt+1})")
                     return img, w, h
             except Exception as e:
-                print(f"[cap] import: {e}")
+                print(f"[cap:{display}] import: {e}")
 
-            # ── Method 3: ffmpeg x11grab ──────────────────────
+            # Method 3: ffmpeg x11grab
             p3 = f"{tmp_base}_a{attempt}_ff.png"
             created_files.append(p3)
             try:
-                sw, sh = _get_screen_size()
+                sw, sh = _get_screen_size(display)
                 subprocess.run([
                     "ffmpeg", "-y", "-f", "x11grab",
                     "-video_size", f"{sw}x{sh}",
-                    "-i", SHARED_DISPLAY,
+                    "-i", display,
                     "-vframes", "1", "-q:v", "1", p3
                 ], env=env, timeout=12, capture_output=True)
                 img, w, h = _try_load(p3)
                 if img and not _is_black_screen(img):
-                    print(f"[cap] ✅ ffmpeg (attempt {attempt+1})")
                     return img, w, h
             except Exception as e:
-                print(f"[cap] ffmpeg: {e}")
+                print(f"[cap:{display}] ffmpeg: {e}")
 
-            # ── Method 4: python-xlib ─────────────────────────
+            # Method 4: python-xlib
             try:
                 from Xlib import display as Xdisp, X
-                xd = Xdisp.Display(SHARED_DISPLAY)
+                xd = Xdisp.Display(display)
                 root = xd.screen().root
                 geom = root.get_geometry()
                 w, h = geom.width, geom.height
@@ -310,31 +392,30 @@ def _capture_raw() -> tuple:
                     pixels[j], pixels[j+1], pixels[j+2] = r_c, g, b
                 img = Image.frombytes("RGB", (w, h), bytes(pixels))
                 if not _is_black_screen(img):
-                    print(f"[cap] ✅ xlib (attempt {attempt+1})")
                     return img, w, h
             except Exception as e:
-                print(f"[cap] xlib: {e}")
+                print(f"[cap:{display}] xlib: {e}")
 
         finally:
             _cleanup_files()
 
-    # إذا فشلت كل المحاولات — placeholder واضح
-    print("[cap] ⚠️ All methods failed or black — placeholder")
+    # Placeholder
+    print(f"[cap:{display}] ⚠️ All methods failed — placeholder")
     from PIL import Image as PILImg, ImageDraw
-    sw, sh = _get_screen_size()
+    sw, sh = _get_screen_size(display)
     img = PILImg.new("RGB", (sw or 1920, sh or 1080), (15, 20, 40))
     draw = ImageDraw.Draw(img)
     draw.rectangle([(0, 0), (sw, 55)], fill=(30, 40, 80))
-    draw.text((10, 10), f"⚠️ Screenshot failed — DISPLAY={SHARED_DISPLAY}", fill=(255, 120, 80))
-    draw.text((10, 32), "Methods tried: scrot, import, ffmpeg, xlib (3 attempts each)", fill=(130, 130, 150))
+    draw.text((10, 10), f"⚠️ Screenshot failed — DISPLAY={display}", fill=(255, 120, 80))
+    draw.text((10, 32), "Methods: scrot, import, ffmpeg, xlib (3 attempts)", fill=(130, 130, 150))
     return img, sw or 1920, sh or 1080
 
 
-def _get_screen_size() -> tuple:
+def _get_screen_size(display: str) -> tuple:
     try:
         r = subprocess.run(
             ["xdotool", "getdisplaygeometry"],
-            env={**os.environ, "DISPLAY": SHARED_DISPLAY},
+            env={**os.environ, "DISPLAY": display},
             capture_output=True, text=True, timeout=5
         )
         parts = r.stdout.strip().split()
@@ -343,11 +424,11 @@ def _get_screen_size() -> tuple:
         return 1920, 1080
 
 
-def _get_mouse_pos() -> tuple:
+def _get_mouse_pos(display: str) -> tuple:
     try:
         r = subprocess.run(
             ["xdotool", "getmouselocation"],
-            env={**os.environ, "DISPLAY": SHARED_DISPLAY},
+            env={**os.environ, "DISPLAY": display},
             capture_output=True, text=True, timeout=5
         )
         mx = int(re.search(r"x:(\d+)", r.stdout).group(1))
@@ -357,27 +438,23 @@ def _get_mouse_pos() -> tuple:
         return 0, 0
 
 
-def capture_with_grid(scale: float = 0.65, quality: int = 72,
+def capture_with_grid(display: str, scale: float = 0.65, quality: int = 72,
                       force_mx: int | None = None,
                       force_my: int | None = None) -> dict:
-    """
-    يلتقط الشاشة ويضيف Grid overlay للذكاء الاصطناعي.
-    يُعيد dict مع base64 JPEG وإحداثيات الشاشة والماوس.
-    """
+    """يلتقط الشاشة من display محدد ويضيف Grid overlay."""
     from PIL import Image, ImageDraw
 
-    img, ow, oh = _capture_raw()
+    img, ow, oh = _capture_raw(display)
     if img is None:
         return {"data": "", "width": 1920, "height": 1080, "mouse_x": 0, "mouse_y": 0}
 
-    mx, my = (force_mx, force_my) if force_mx is not None else _get_mouse_pos()
+    mx, my = (force_mx, force_my) if force_mx is not None else _get_mouse_pos(display)
 
     sw = int(ow * scale)
     sh = int(oh * scale)
     grid_img = img.resize((sw, sh), Image.LANCZOS)
     draw = ImageDraw.Draw(grid_img, "RGBA")
 
-    # خطوط Grid كل 100px
     step_x = int(100 * sw / ow)
     step_y = int(100 * sh / oh)
     gc = (255, 255, 255, 40)
@@ -397,7 +474,6 @@ def capture_with_grid(scale: float = 0.65, quality: int = 72,
         draw.text((3, y_sc+2), str(y_r), fill=lc)
         y_sc += step_y; y_r += 100
 
-    # cursor
     msx = int(mx * sw / ow)
     msy = int(my * sh / oh)
     r = 11
@@ -405,11 +481,10 @@ def capture_with_grid(scale: float = 0.65, quality: int = 72,
     draw.line([(msx-18, msy), (msx+18, msy)], fill=(255, 50, 50, 200), width=1)
     draw.line([(msx, msy-18), (msx, msy+18)], fill=(255, 50, 50, 200), width=1)
 
-    # header bar
     final = grid_img.convert("RGB")
     draw2 = ImageDraw.Draw(final)
     draw2.rectangle([(0, 0), (sw, 20)], fill=(0, 0, 0))
-    draw2.text((4, 3), f"SCREEN {ow}x{oh} | MOUSE:({mx},{my}) | GRID=100px", fill=(0, 220, 160))
+    draw2.text((4, 3), f"SCREEN {ow}x{oh} | MOUSE:({mx},{my}) | GRID=100px | DSP:{display}", fill=(0, 220, 160))
     draw2.rectangle([(0, sh-20), (sw, sh)], fill=(0, 0, 0))
     draw2.text((4, sh-17), "CLICK COORDS = numbers on grid lines (real screen pixels)", fill=(180, 180, 70))
 
@@ -421,12 +496,11 @@ def capture_with_grid(scale: float = 0.65, quality: int = 72,
 
 
 def _frame_hash(data: str) -> str:
-    """hash سريع للـ base64 للكشف عن تغيير الصورة."""
     return hashlib.md5(data[:2000].encode()).hexdigest()
 
 
 # ════════════════════════════════════════════════════════════════
-# ── SafeSearch Enforcement ────────────────────────────────────
+# ── SafeSearch ───────────────────────────────────────────────
 # ════════════════════════════════════════════════════════════════
 
 _BING_RE = re.compile(r"https?://(?:www\.)?bing\.com[^\s'\"]*")
@@ -447,7 +521,7 @@ def _safe_search(text: str) -> str:
 
 
 # ════════════════════════════════════════════════════════════════
-# ── Terminal Execution ────────────────────────────────────────
+# ── Terminal Execution (per-display) ───────────────────────��─
 # ════════════════════════════════════════════════════════════════
 
 _PKILL_RE = re.compile(r"\b(pkill|killall)\s+(-9\s+)?-f\s+(['\"]?)([a-zA-Z0-9_./-]+)\3")
@@ -460,11 +534,11 @@ def _sanitize_pkill(cmd: str) -> str:
     return _PKILL_RE.sub(_fix, cmd)
 
 
-async def run_cmd(cmd: str, timeout: int = 60) -> dict:
-    """ينفّذ أمر bash مع rate limit وsafe search."""
+async def run_cmd(cmd: str, display: str, timeout: int = 60) -> dict:
+    """ينفّذ أمر bash مع DISPLAY خاص بالمستخدم."""
     cmd = _sanitize_pkill(_safe_search(cmd))
     async with _terminal_sem:
-        env = {**os.environ, "DISPLAY": SHARED_DISPLAY,
+        env = {**os.environ, "DISPLAY": display,
                "PYTHONIOENCODING": "utf-8", "LANG": "en_US.UTF-8"}
 
         def _exec():
@@ -483,11 +557,11 @@ async def run_cmd(cmd: str, timeout: int = 60) -> dict:
 
 
 # ════════════════════════════════════════════════════════════════
-# ── xdotool helpers ──────────────────────────────────────────
+# ── xdotool helpers (per-display) ────────────────────────────
 # ════════════════════════════════════════════════════════════════
 
-async def xdo(args: list, timeout: int = 10) -> dict:
-    env = {**os.environ, "DISPLAY": SHARED_DISPLAY}
+async def xdo(args: list, display: str, timeout: int = 10) -> dict:
+    env = {**os.environ, "DISPLAY": display}
     def _run():
         r = subprocess.run(
             ["xdotool"] + args, env=env,
@@ -497,10 +571,10 @@ async def xdo(args: list, timeout: int = 10) -> dict:
     return await asyncio.to_thread(_run)
 
 
-async def type_smart(text: str) -> dict:
-    """كتابة نص ذكية: clipboard للعربية، xdotool type للإنجليزية."""
+async def type_smart(text: str, display: str) -> dict:
+    """كتابة نص ذكية بـ display محدد."""
     has_arabic = bool(re.search(r'[\u0600-\u06FF]', text))
-    env = {**os.environ, "DISPLAY": SHARED_DISPLAY}
+    env = {**os.environ, "DISPLAY": display}
 
     if has_arabic:
         def _paste():
@@ -511,76 +585,52 @@ async def type_smart(text: str) -> dict:
             p.communicate(text.encode("utf-8"))
         await asyncio.to_thread(_paste)
         await asyncio.sleep(0.15)
-        await xdo(["key", "--clearmodifiers", "ctrl+v"])
+        await xdo(["key", "--clearmodifiers", "ctrl+v"], display)
         return {"method": "clipboard+paste"}
     else:
-        r = await xdo(["type", "--clearmodifiers", "--delay", "25", text])
+        r = await xdo(["type", "--clearmodifiers", "--delay", "25", text], display)
         return {"method": "xdotool", "rc": r["rc"]}
 
 
 # ════════════════════════════════════════════════════════════════
-# ── Search Sources (8 sources with smart fallback) ──────────
+# ── Search Sources ────────────────────────────────────────────
 # ════════════════════════════════════════════════════════════════
 
 def _search_sources(query: str) -> list:
     q = urllib.parse.quote_plus(query)
     return [
-        {
-            "name": "DuckDuckGo Instant",
-            "cmd": f"curl -s --max-time 15 'https://api.duckduckgo.com/?q={q}&format=json&no_html=1&skip_disambig=1' | python3 -c \"import sys,json;d=json.load(sys.stdin);a=d.get('AbstractText','');r=d.get('RelatedTopics',[]);print('ANS:',a or 'none');[print('-',x.get('Text','')[:200]) for x in r[:6] if isinstance(x,dict)]\""
-        },
-        {
-            "name": "Google News RSS",
-            "cmd": f"curl -sL --max-time 15 'https://news.google.com/rss/search?q={q}&hl=ar&gl=AR&ceid=AR:ar' | python3 -c \"import sys,re;x=sys.stdin.read();t=re.findall(r'<title><!\\[CDATA\\[(.*?)\\]\\]></title>|<title>(.*?)</title>',x);[(print(str(i+1)+'. '+(a or b).strip()[:160])) for i,(a,b) in enumerate(t[1:8]) if (a or b).strip()]\""
-        },
-        {
-            "name": "Wikipedia EN",
-            "cmd": f"curl -s --max-time 12 'https://en.wikipedia.org/api/rest_v1/page/summary/{q}' | python3 -c \"import sys,json;d=json.load(sys.stdin);print(d.get('title','')+'\\n'+d.get('extract','')[:1200])\""
-        },
-        {
-            "name": "DuckDuckGo HTML",
-            "cmd": f"curl -sL --max-time 15 -H 'User-Agent: Mozilla/5.0' 'https://html.duckduckgo.com/html/?q={q}' | python3 -c \"import sys,re;h=sys.stdin.read();s=re.findall(r'class=.result__snippet[^>]*>(.*?)</a>',h,re.DOTALL);clean=lambda x:re.sub('<[^>]+>','',x).strip();[print(str(i+1)+'. '+clean(x)[:200]) for i,x in enumerate(s[:7])]\""
-        },
-        {
-            "name": "HackerNews",
-            "cmd": f"curl -s --max-time 12 'https://hn.algolia.com/api/v1/search?query={q}&hitsPerPage=6&tags=story' | python3 -c \"import sys,json;d=json.load(sys.stdin);[print(str(i+1)+'. '+h.get('title','')+'  Pts:'+str(h.get('points',0))) for i,h in enumerate(d.get('hits',[])[:5])]\""
-        },
-        {
-            "name": "Bing News RSS",
-            "cmd": f"curl -sL --max-time 15 'https://www.bing.com/news/search?q={q}&format=RSS' | python3 -c \"import sys,re;x=sys.stdin.read();items=re.findall(r'<item>(.*?)</item>',x,re.DOTALL);[print(str(i+1)+'. '+re.sub('<[^>]+>','',re.search(r'<title>(.*?)</title>',it).group(1) if re.search(r'<title>',it) else '')) for i,it in enumerate(items[:6])]\""
-        },
-        {
-            "name": "ArXiv",
-            "cmd": f"curl -s --max-time 12 'https://export.arxiv.org/api/query?search_query=all:{q}&max_results=5' | python3 -c \"import sys,re;x=sys.stdin.read();t=re.findall(r'<title>(.*?)</title>',x)[1:];[print(str(i+1)+'. '+ti.strip()) for i,ti in enumerate(t[:5])]\""
-        },
-        {
-            "name": "Reddit",
-            "cmd": f"curl -sL --max-time 12 -H 'Accept: application/json' 'https://www.reddit.com/search.json?q={q}&sort=new&limit=6' | python3 -c \"import sys,json;d=json.load(sys.stdin);[print(str(i+1)+'. '+p['data'].get('title','')[:160]) for i,p in enumerate(d.get('data',{{}}).get('children',[])[:5])]\""
-        },
+        {"name": "DuckDuckGo Instant",
+         "cmd": f"curl -s --max-time 15 'https://api.duckduckgo.com/?q={q}&format=json&no_html=1&skip_disambig=1' | python3 -c \"import sys,json;d=json.load(sys.stdin);a=d.get('AbstractText','');r=d.get('RelatedTopics',[]);print('ANS:',a or 'none');[print('-',x.get('Text','')[:200]) for x in r[:6] if isinstance(x,dict)]\""},
+        {"name": "Google News RSS",
+         "cmd": f"curl -sL --max-time 15 'https://news.google.com/rss/search?q={q}&hl=ar&gl=AR&ceid=AR:ar' | python3 -c \"import sys,re;x=sys.stdin.read();t=re.findall(r'<title><!\\[CDATA\\[(.*?)\\]\\]></title>|<title>(.*?)</title>',x);[(print(str(i+1)+'. '+(a or b).strip()[:160])) for i,(a,b) in enumerate(t[1:8]) if (a or b).strip()]\""},
+        {"name": "Wikipedia EN",
+         "cmd": f"curl -s --max-time 12 'https://en.wikipedia.org/api/rest_v1/page/summary/{q}' | python3 -c \"import sys,json;d=json.load(sys.stdin);print(d.get('title','')+'\\n'+d.get('extract','')[:1200])\""},
+        {"name": "DuckDuckGo HTML",
+         "cmd": f"curl -sL --max-time 15 -H 'User-Agent: Mozilla/5.0' 'https://html.duckduckgo.com/html/?q={q}' | python3 -c \"import sys,re;h=sys.stdin.read();s=re.findall(r'class=.result__snippet[^>]*>(.*?)</a>',h,re.DOTALL);clean=lambda x:re.sub('<[^>]+>','',x).strip();[print(str(i+1)+'. '+clean(x)[:200]) for i,x in enumerate(s[:7])]\""},
+        {"name": "HackerNews",
+         "cmd": f"curl -s --max-time 12 'https://hn.algolia.com/api/v1/search?query={q}&hitsPerPage=6&tags=story' | python3 -c \"import sys,json;d=json.load(sys.stdin);[print(str(i+1)+'. '+h.get('title','')+'  Pts:'+str(h.get('points',0))) for i,h in enumerate(d.get('hits',[])[:5])]\""},
+        {"name": "Reddit",
+         "cmd": f"curl -sL --max-time 12 -H 'Accept: application/json' 'https://www.reddit.com/search.json?q={q}&sort=new&limit=6' | python3 -c \"import sys,json;d=json.load(sys.stdin);[print(str(i+1)+'. '+p['data'].get('title','')[:160]) for i,p in enumerate(d.get('data',{{}}).get('children',[])[:5])]\""},
     ]
 
 
 def _result_empty(s: str) -> bool:
     if not s or len(s.strip()) < 15:
         return True
-    bad = ["no direct answer", "ans: none", "error", "not found", "[]", "empty"]
-    return all(b in s.lower() for b in bad[:1])
+    return "ans: none" in s.lower()
 
 
-async def run_cmd_smart(cmd: str, timeout: int = 60) -> dict:
-    """يُنفّذ أمر وإذا فشل يجرب 8 مصادر بحث بديلة."""
-    res = await run_cmd(cmd, timeout)
+async def run_cmd_smart(cmd: str, display: str, timeout: int = 60) -> dict:
+    res = await run_cmd(cmd, display, timeout)
     if res["returncode"] == 0 and not _result_empty(res["stdout"]):
         return res
 
-    # هل هو أمر بحث؟
     is_search = "curl" in cmd and any(
         x in cmd for x in ["search", "duckduck", "bing", "google", "wikipedia", "reddit"]
     )
     if not is_search:
         return res
 
-    # استخرج query
     m = re.search(r"[?&]q=([^&'\"\s]+)", cmd)
     query = urllib.parse.unquote(m.group(1).replace("+", " ")).strip() if m else ""
     if len(query) < 3:
@@ -589,7 +639,7 @@ async def run_cmd_smart(cmd: str, timeout: int = 60) -> dict:
     sources = _search_sources(query)
     results = []
     for src in sources:
-        r2 = await run_cmd(src["cmd"], 20)
+        r2 = await run_cmd(src["cmd"], display, 20)
         if not _result_empty(r2["stdout"]):
             results.append(f"[{src['name']}]\n{r2['stdout']}")
             if len(results) >= 2:
@@ -604,42 +654,50 @@ async def run_cmd_smart(cmd: str, timeout: int = 60) -> dict:
 # ── FastAPI App ───────────────────────────────────────────────
 # ════════════════════════════════════════════════════════════════
 
-app = FastAPI(title="Z-Computer-Mode v8")
+app = FastAPI(title="Z-Computer-Mode v11 — Per-User Isolation")
 app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True,
                    allow_methods=["*"], allow_headers=["*"])
 
-active_connections: list[WebSocket] = []
-
 
 @app.get("/", response_class=HTMLResponse)
 async def root():
-    w, h = _get_screen_size()
-    n = len(_active_sessions)
+    n = len(_user_displays)
+    users_info = ""
+    with _display_lock:
+        for uid, sess in _user_displays.items():
+            ws_status = "🟢 متصل" if sess.get("active_ws") else "⚫ غير متصل"
+            users_info += f"<tr><td>{uid[:30]}...</td><td>{sess['display']}</td><td>{ws_status}</td></tr>"
+
     return f"""<!DOCTYPE html><html><head><meta charset="utf-8">
-<title>Z Computer Mode v8</title>
+<title>Z Computer Mode v11</title>
 <style>body{{background:#080808;color:#00d4aa;font-family:monospace;padding:40px}}
-h1{{color:#4a90d9}}.ok{{color:#00ff88}}.info{{color:#888;font-size:13px}}</style>
+h1{{color:#4a90d9}}.ok{{color:#00ff88}}.info{{color:#888;font-size:13px}}
+table{{border-collapse:collapse;width:100%}}td,th{{border:1px solid #333;padding:6px 10px;font-size:13px}}
+th{{background:#1a1a2e;color:#4a90d9}}</style>
 </head><body>
-<h1>🖥️ THE Z AI — Computer Mode Server v8</h1>
-<p class="ok">✅ Server RUNNING</p>
+<h1>🖥️ THE Z AI — Computer Mode Server v11</h1>
+<p class="ok">✅ Server RUNNING — Per-User Isolated Displays</p>
 <p>🌐 Browser: <b>{BROWSER}</b></p>
-<p>📐 Screen: <b>{w}x{h}</b></p>
-<p>👥 Active sessions: <b>{n}</b></p>
-<p>🖥️ Display: <b>{SHARED_DISPLAY}</b></p>
-<p>🔌 WebSocket: <b>wss://your-space.hf.space/ws</b></p>
+<p>👥 Active users: <b>{n}</b></p>
+<p>📋 Display range: <b>:{DISPLAY_BASE} → :{DISPLAY_MAX}</b></p>
+<hr style="border-color:#333">
+<h3>👤 User Sessions</h3>
+<table><tr><th>User ID</th><th>Display</th><th>Status</th></tr>
+{users_info or '<tr><td colspan="3" style="text-align:center;color:#666">No active sessions</td></tr>'}
+</table>
 <hr style="border-color:#333">
-<p class="info">Endpoints: /health · /screenshot · /ws (WebSocket)</p>
+<p class="info">Endpoints: /health · /ws?user_id=email (WebSocket)</p>
 </body></html>"""
 
 
 # ════════════════════════════════════════════════════════════════
-# ── Action Handler ────────────────────────────────────────────
+# ── Action Handler (per-session) ─────────────────────────────
 # ════════════════════════════════════════════════════════════════
 
 async def handle_action(ws: WebSocket, msg: dict, sess: dict):
-    action = msg.get("action", "")
-    data   = msg.get("data", {})
-    sid    = id(ws)
+    action  = msg.get("action", "")
+    data    = msg.get("data", {})
+    display = sess["display"]
 
     async def send(obj):
         try:
@@ -649,38 +707,29 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
 
     async def shot_bg(label: str = "", delay: float = 0.5,
                       force_mx: int | None = None, force_my: int | None = None):
-        """
-        auto_shot في الخلفية — فقط للمعاينة البصرية (بعد mouse/keyboard/scroll).
-        يطبّق: rate limit + delta suppression.
-        لا يُرسل إذا الصورة لم تتغير — المستخدم يرى التحديث عند الطلب الصريح.
-        """
+        """auto_shot في الخلفية — مع rate limit + delta suppression."""
         await asyncio.sleep(delay)
-
-        # Rate limit: لا أكثر من لقطة كل 0.3 ثانية لنفس الجلسة
         now = time.time()
         if now - sess.get("last_bg_shot_ts", 0) < 0.3:
             await asyncio.sleep(0.3 - (now - sess["last_bg_shot_ts"]))
 
         result = await asyncio.to_thread(
-            capture_with_grid, 0.65, 72, force_mx, force_my
+            capture_with_grid, display, 0.65, 72, force_mx, force_my
         )
         sess["last_bg_shot_ts"] = time.time()
-
         if not result["data"]:
             return
 
-        # Delta suppression: لا ترسل إذا الصورة لم تتغير
         fh = _frame_hash(result["data"])
         if fh == sess.get("last_bg_hash", ""):
-            return  # لم تتغير — لا ترسل
+            return
         sess["last_bg_hash"] = fh
 
         await send({
             "type": "screenshot",
             "data": result["data"],
             "ts": int(time.time() * 1000),
-            "auto": True,
-            "label": label,
+            "auto": True, "label": label,
             "screen_width": result["width"],
             "screen_height": result["height"],
             "mouse_x": result["mouse_x"],
@@ -689,22 +738,16 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
         })
 
     async def shot_explicit(label: str = ""):
-        """
-        screenshot صريح — يُرسل دائماً بدون delta suppression ولا rate limit.
-        يُستخدم عند action == "screenshot" أو بعد terminal/open_app.
-        الـ HTML ينتظر هذا الرد بمقارنة _pcLastFrameTs — يجب أن يصل دائماً.
-        """
-        result = await asyncio.to_thread(capture_with_grid, 0.65, 75)
+        """screenshot صريح — يُرسل دائماً بدون delta suppression."""
+        result = await asyncio.to_thread(capture_with_grid, display, 0.65, 75)
         if not result["data"]:
             return
-        # حدّث hash الخلفي أيضاً لمنع إرسال نفس الصورة مرتين في auto_shot
         sess["last_bg_hash"] = _frame_hash(result["data"])
         await send({
             "type": "screenshot",
             "data": result["data"],
             "ts": int(time.time() * 1000),
-            "auto": False,
-            "label": label,
+            "auto": False, "label": label,
             "screen_width": result["width"],
             "screen_height": result["height"],
             "mouse_x": result["mouse_x"],
@@ -712,7 +755,18 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
             "has_grid": True,
         })
 
-    # ── screenshot (صريح من الـ HTML — يُرسل دائماً بدون تأخير) ──────
+    # ── reset_computer: إعادة ضبط الكمبيوتر كأنه جديد ─────────
+    if action == "reset_computer":
+        user_id = sess["user_id"]
+        await send({"type": "ack", "action": "reset_computer", "status": "resetting"})
+        await reset_user_computer(user_id)
+        # أرسل لقطة شاشة بعد الريستارت
+        await asyncio.sleep(2.0)
+        await shot_explicit("after reset")
+        await send({"type": "computer_reset", "msg": "✅ تم إعادة ضبط الكمبيوتر — الشاشة جديدة تماماً"})
+        return
+
+    # ── screenshot ────────────────────────────────────────────
     if action == "screenshot":
         await shot_explicit("explicit screenshot")
 
@@ -722,7 +776,7 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
         if not cmd:
             await send({"type": "terminal_result", "stdout": "", "stderr": "no cmd", "returncode": -1})
             return
-        res = await run_cmd_smart(cmd, int(data.get("timeout", 60)))
+        res = await run_cmd_smart(cmd, display, int(data.get("timeout", 60)))
         await send({
             "type": "terminal_result",
             "cmd": cmd,
@@ -730,13 +784,12 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
             "stderr": res.get("stderr", ""),
             "returncode": res["returncode"],
         })
-        # screenshot صريح بعد terminal — الـ HTML ينتظره
         asyncio.create_task(shot_explicit(f"after terminal"))
 
     # ── mouse_move ───────────────────────────────────────────
     elif action == "mouse_move":
         x, y = int(data.get("x", 0)), int(data.get("y", 0))
-        await xdo(["mousemove", "--sync", str(x), str(y)])
+        await xdo(["mousemove", "--sync", str(x), str(y)], display)
         await send({"type": "ack", "action": "mouse_move", "x": x, "y": y})
         asyncio.create_task(shot_bg(f"move ({x},{y})", delay=0.2, force_mx=x, force_my=y))
 
@@ -745,12 +798,12 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
         x, y   = int(data.get("x", 0)), int(data.get("y", 0))
         btn    = {"left": "1", "middle": "2", "right": "3"}.get(data.get("button", "left"), "1")
         double = data.get("double", False)
-        await xdo(["mousemove", "--sync", str(x), str(y)])
+        await xdo(["mousemove", "--sync", str(x), str(y)], display)
         await asyncio.sleep(0.07)
         if double:
-            await xdo(["click", "--repeat", "2", "--delay", "100", btn])
+            await xdo(["click", "--repeat", "2", "--delay", "100", btn], display)
         else:
-            await xdo(["click", btn])
+            await xdo(["click", btn], display)
         btn_name = {"1": "left", "2": "middle", "3": "right"}.get(btn, "left")
         await send({"type": "ack", "action": "mouse_click", "x": x, "y": y, "button": btn_name})
         asyncio.create_task(shot_bg(f"click {btn_name} ({x},{y})", delay=0.5, force_mx=x, force_my=y))
@@ -759,12 +812,12 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
     elif action == "mouse_drag":
         x1, y1 = int(data.get("x1", 0)), int(data.get("y1", 0))
         x2, y2 = int(data.get("x2", 0)), int(data.get("y2", 0))
-        await xdo(["mousemove", str(x1), str(y1)])
-        await xdo(["mousedown", "1"])
+        await xdo(["mousemove", str(x1), str(y1)], display)
+        await xdo(["mousedown", "1"], display)
         await asyncio.sleep(0.1)
-        await xdo(["mousemove", str(x2), str(y2)])
+        await xdo(["mousemove", str(x2), str(y2)], display)
         await asyncio.sleep(0.1)
-        await xdo(["mouseup", "1"])
+        await xdo(["mouseup", "1"], display)
         await send({"type": "ack", "action": "mouse_drag"})
         asyncio.create_task(shot_bg("after drag", delay=0.4, force_mx=x2, force_my=y2))
 
@@ -772,7 +825,7 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
     elif action == "keyboard_type":
         text = _safe_search(data.get("text", ""))
         if text:
-            res = await type_smart(text)
+            res = await type_smart(text, display)
             await send({"type": "ack", "action": "keyboard_type", "method": res["method"]})
         asyncio.create_task(shot_bg("after type", delay=0.5))
 
@@ -780,7 +833,7 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
     elif action == "keyboard_hotkey":
         keys = data.get("keys", [])
         if keys:
-            await xdo(["key", "--clearmodifiers", "+".join(keys)])
+            await xdo(["key", "--clearmodifiers", "+".join(keys)], display)
         await send({"type": "ack", "action": "keyboard_hotkey", "keys": keys})
         asyncio.create_task(shot_bg("after hotkey", delay=0.4))
 
@@ -788,7 +841,7 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
     elif action == "keyboard_press":
         key = data.get("key", "")
         if key:
-            await xdo(["key", "--clearmodifiers", key])
+            await xdo(["key", "--clearmodifiers", key], display)
         await send({"type": "ack", "action": "keyboard_press"})
         asyncio.create_task(shot_bg("after key", delay=0.4))
 
@@ -797,9 +850,9 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
         x, y   = int(data.get("x", 960)), int(data.get("y", 540))
         clicks = max(-5, min(5, int(data.get("clicks", 3))))
         btn    = "4" if clicks > 0 else "5"
-        await xdo(["mousemove", str(x), str(y)])
+        await xdo(["mousemove", str(x), str(y)], display)
         for _ in range(abs(clicks)):
-            await xdo(["click", btn])
+            await xdo(["click", btn], display)
             await asyncio.sleep(0.025)
         await send({"type": "ack", "action": "scroll", "clicks": clicks})
         asyncio.create_task(shot_bg("after scroll", delay=0.4))
@@ -807,7 +860,7 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
     # ── clipboard_write ──────────────────────────────────────
     elif action == "clipboard_write":
         text = data.get("text", "")
-        env  = {**os.environ, "DISPLAY": SHARED_DISPLAY}
+        env  = {**os.environ, "DISPLAY": display}
         def _clip():
             p = subprocess.Popen(["xclip", "-selection", "clipboard"], stdin=subprocess.PIPE, env=env)
             p.communicate(text.encode("utf-8"))
@@ -816,20 +869,20 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
 
     # ── clipboard_read ───────────────────────────────────────
     elif action == "clipboard_read":
-        res = await run_cmd("xclip -selection clipboard -o", 5)
+        res = await run_cmd("xclip -selection clipboard -o", display, 5)
         await send({"type": "clipboard_content", "text": res["stdout"]})
 
     # ── paste ────────────────────────────────────────────────
     elif action == "paste":
         text = data.get("text", "")
         if text:
-            env  = {**os.environ, "DISPLAY": SHARED_DISPLAY}
+            env  = {**os.environ, "DISPLAY": display}
             def _clip2():
                 p = subprocess.Popen(["xclip", "-selection", "clipboard"], stdin=subprocess.PIPE, env=env)
                 p.communicate(text.encode("utf-8"))
             await asyncio.to_thread(_clip2)
             await asyncio.sleep(0.1)
-            await xdo(["key", "--clearmodifiers", "ctrl+v"])
+            await xdo(["key", "--clearmodifiers", "ctrl+v"], display)
         await send({"type": "ack", "action": "paste"})
         asyncio.create_task(shot_bg("after paste", delay=0.5))
 
@@ -839,24 +892,20 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
         if not cmd:
             await send({"type": "ack", "action": "open_app"})
             return
-
-        # نظّف lock files قبل فتح Firefox (يمنع "already running" dialog)
         if "firefox" in cmd.lower():
             await run_cmd(
                 "pkill -f '[f]irefox' 2>/dev/null; sleep 0.5; "
                 "rm -f ~/.mozilla/firefox/*/lock ~/.mozilla/firefox/*/.parentlock 2>/dev/null; "
                 "echo CLEANED",
-                timeout=8
+                display, timeout=8
             )
-
-        env = {**os.environ, "DISPLAY": SHARED_DISPLAY}
-        proc = subprocess.Popen(
-            cmd, shell=True, env=env,
-            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
-        )
+        env = {**os.environ, "DISPLAY": display}
+        proc = subprocess.Popen(cmd, shell=True, env=env,
+                                stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
         if any(b in cmd for b in ("firefox", "chromium", "chrome")):
-            sess["browser_proc"] = proc
-
+            with _display_lock:
+                if sess["user_id"] in _user_displays:
+                    _user_displays[sess["user_id"]]["browser_proc"] = proc
         await send({"type": "ack", "action": "open_app", "cmd": cmd})
         async def _open_app_shots():
             await asyncio.sleep(3.0)
@@ -868,17 +917,21 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
     # ── open_browser ─────────────────────────────────────────
     elif action == "open_browser":
         url = _safe_search(data.get("url", "") or "about:blank")
-        # نظّف أي Firefox قديم أولاً
+        # قتل Firefox القديم الخاص بهذا المستخدم فقط
         await run_cmd(
             "pkill -f '[f]irefox' 2>/dev/null; sleep 0.5; "
             "rm -f ~/.mozilla/firefox/*/lock ~/.mozilla/firefox/*/.parentlock 2>/dev/null; "
             "echo CLEANED",
-            timeout=8
+            display, timeout=8
         )
-        cmd = get_browser_cmd(url)
-        env = {**os.environ, "DISPLAY": SHARED_DISPLAY}
-        proc = subprocess.Popen(cmd, env=env, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-        sess["browser_proc"] = proc
+        env = {**os.environ, "DISPLAY": display}
+        proc = subprocess.Popen(
+            [BROWSER, "--no-remote", url], env=env,
+            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
+        )
+        with _display_lock:
+            if sess["user_id"] in _user_displays:
+                _user_displays[sess["user_id"]]["browser_proc"] = proc
         await send({"type": "ack", "action": "open_browser", "url": url})
         async def _open_browser_shots():
             await asyncio.sleep(3.0)
@@ -890,55 +943,55 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
     # ── open_tab ─────────────────────────────────────────────
     elif action == "open_tab":
         url = _safe_search(data.get("url", "") or "about:blank")
-        await xdo(["key", "--clearmodifiers", "ctrl+t"])
+        await xdo(["key", "--clearmodifiers", "ctrl+t"], display)
         await asyncio.sleep(0.4)
-        await xdo(["key", "--clearmodifiers", "ctrl+l"])
+        await xdo(["key", "--clearmodifiers", "ctrl+l"], display)
         await asyncio.sleep(0.2)
-        await type_smart(url)
+        await type_smart(url, display)
         await asyncio.sleep(0.2)
-        await xdo(["key", "--clearmodifiers", "Return"])
+        await xdo(["key", "--clearmodifiers", "Return"], display)
         await send({"type": "ack", "action": "open_tab", "url": url})
         asyncio.create_task(shot_bg("after open_tab", delay=1.5))
 
     # ── close_tab ────────────────────────────────────────────
     elif action == "close_tab":
-        await xdo(["key", "--clearmodifiers", "ctrl+w"])
+        await xdo(["key", "--clearmodifiers", "ctrl+w"], display)
         await send({"type": "ack", "action": "close_tab"})
         asyncio.create_task(shot_bg("after close_tab", delay=0.5))
 
     # ── browser_back ─────────────────────────────────────────
     elif action == "browser_back":
-        await xdo(["key", "--clearmodifiers", "alt+Left"])
+        await xdo(["key", "--clearmodifiers", "alt+Left"], display)
         await send({"type": "ack", "action": "browser_back"})
         asyncio.create_task(shot_bg("after back", delay=0.8))
 
     # ── browser_forward ──────────────────────────────────────
     elif action == "browser_forward":
-        await xdo(["key", "--clearmodifiers", "alt+Right"])
+        await xdo(["key", "--clearmodifiers", "alt+Right"], display)
         await send({"type": "ack", "action": "browser_forward"})
         asyncio.create_task(shot_bg("after forward", delay=0.8))
 
     # ── browser_search ───────────────────────────────────────
     elif action == "browser_search":
         url = _safe_search(data.get("url", "") or data.get("query", ""))
-        await xdo(["key", "--clearmodifiers", "ctrl+l"])
+        await xdo(["key", "--clearmodifiers", "ctrl+l"], display)
         await asyncio.sleep(0.2)
-        await type_smart(url)
+        await type_smart(url, display)
         await asyncio.sleep(0.15)
-        await xdo(["key", "--clearmodifiers", "Return"])
+        await xdo(["key", "--clearmodifiers", "Return"], display)
         await send({"type": "ack", "action": "browser_search"})
         asyncio.create_task(shot_bg("after search", delay=1.5))
 
     # ── screen_info ──────────────────────────────────────────
     elif action == "screen_info":
-        w, h   = await asyncio.to_thread(_get_screen_size)
-        mx, my = await asyncio.to_thread(_get_mouse_pos)
+        w, h   = await asyncio.to_thread(_get_screen_size, display)
+        mx, my = await asyncio.to_thread(_get_mouse_pos, display)
         await send({
             "type": "screen_info",
             "width": w, "height": h,
             "mouse_x": mx, "mouse_y": my,
             "browser": BROWSER,
-            "display": SHARED_DISPLAY,
+            "display": display,
         })
 
     # ── unknown ──────────────────────────────────────────────
@@ -947,18 +1000,25 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
 
 
 # ════════════════════════════════════════════════════════════════
-# ── WebSocket Endpoint with Heartbeat ────────────────────────
+# ── WebSocket Endpoint ────────────────────────────────────────
 # ════════════════════════════════════════════════════════════════
 
 @app.websocket("/ws")
-async def websocket_endpoint(ws: WebSocket):
+async def websocket_endpoint(
+    ws: WebSocket,
+    user_id: str = Query(default="anonymous")
+):
     await ws.accept()
-    active_connections.append(ws)
 
-    sess = await create_session(ws)
+    # الحصول على session المستخدم أو إنشاء واحدة جديدة
+    sess = await get_or_create_user_session(user_id, ws)
+
+    # تأكد أن Xvfb يعمل لهذا المستخدم
+    await ensure_xvfb_for_session(sess)
+
+    display = sess["display"]
 
     async def _heartbeat():
-        """Ping كل 20 ثانية لمنع قطع الاتصال من proxies."""
         while True:
             await asyncio.sleep(20)
             try:
@@ -969,18 +1029,19 @@ async def websocket_endpoint(ws: WebSocket):
     hb_task = asyncio.create_task(_heartbeat())
 
     try:
-        w, h = await asyncio.to_thread(_get_screen_size)
+        w, h = await asyncio.to_thread(_get_screen_size, display)
         await ws.send_text(json.dumps({
             "type": "connected",
             "screen_width": w, "screen_height": h,
             "browser": BROWSER,
-            "display": SHARED_DISPLAY,
+            "display": display,
+            "user_id": user_id,
             "session_id": id(ws),
-            "msg": f"Z Computer Mode v10 | Browser: {BROWSER} | Screen: {w}x{h}",
+            "msg": f"Z Computer Mode v11 | User: {user_id} | Display: {display} | Browser: {BROWSER} | Screen: {w}x{h}",
         }, ensure_ascii=False))
 
-        # لقطة شاشة أولية — دائماً تُرسل بغض النظر عن أي شيء
-        result = await asyncio.to_thread(capture_with_grid, 0.65, 72)
+        # لقطة شاشة أولية
+        result = await asyncio.to_thread(capture_with_grid, display, 0.65, 72)
         if result["data"]:
             await ws.send_text(json.dumps({
                 "type": "screenshot",
@@ -996,14 +1057,13 @@ async def websocket_endpoint(ws: WebSocket):
             sess["last_bg_hash"] = _frame_hash(result["data"])
 
     except Exception as e:
-        print(f"[ws] init error: {e}")
+        print(f"[ws:{user_id}] init error: {e}")
 
     try:
         while True:
             raw = await ws.receive_text()
             try:
                 msg = json.loads(raw)
-                # تجاهل pong responses
                 if msg.get("type") == "pong":
                     continue
                 await handle_action(ws, msg, sess)
@@ -1012,12 +1072,10 @@ async def websocket_endpoint(ws: WebSocket):
     except WebSocketDisconnect:
         pass
     except Exception as e:
-        print(f"[ws] error: {e}")
+        print(f"[ws:{user_id}] error: {e}")
     finally:
         hb_task.cancel()
-        if ws in active_connections:
-            active_connections.remove(ws)
-        await destroy_session(ws)
+        await destroy_user_ws(user_id, ws)
 
 
 # ════════════════════════════════════════════════════════════════
@@ -1025,8 +1083,11 @@ async def websocket_endpoint(ws: WebSocket):
 # ════════════════════════════════════════════════════════════════
 
 @app.get("/screenshot")
-async def rest_screenshot():
-    result = await asyncio.to_thread(capture_with_grid, 0.7, 75)
+async def rest_screenshot(user_id: str = "anonymous"):
+    with _display_lock:
+        sess = _user_displays.get(user_id)
+    display = sess["display"] if sess else f":{DISPLAY_BASE}"
+    result = await asyncio.to_thread(capture_with_grid, display, 0.7, 75)
     return JSONResponse({
         "image": result["data"],
         "ts": int(time.time() * 1000),
@@ -1035,24 +1096,33 @@ async def rest_screenshot():
         "mouse_x": result["mouse_x"],
         "mouse_y": result["mouse_y"],
         "has_grid": True,
+        "display": display,
+        "user_id": user_id,
     })
 
 @app.post("/terminal")
 async def rest_terminal(body: dict):
-    return JSONResponse(await run_cmd_smart(body.get("cmd", ""), body.get("timeout", 60)))
+    user_id = body.get("user_id", "anonymous")
+    with _display_lock:
+        sess = _user_displays.get(user_id)
+    display = sess["display"] if sess else f":{DISPLAY_BASE}"
+    return JSONResponse(await run_cmd_smart(body.get("cmd", ""), display, body.get("timeout", 60)))
 
 @app.get("/health")
 async def health():
-    w, h   = await asyncio.to_thread(_get_screen_size)
-    mx, my = await asyncio.to_thread(_get_mouse_pos)
+    with _display_lock:
+        n = len(_user_displays)
+        users = [
+            {"user_id": uid, "display": s["display"],
+             "connected": bool(s.get("active_ws"))}
+            for uid, s in _user_displays.items()
+        ]
     return {
         "status": "ok",
-        "version": "v8-stable",
+        "version": "v11-per-user-isolation",
         "browser": BROWSER,
-        "display": SHARED_DISPLAY,
-        "screen": f"{w}x{h}",
-        "mouse": f"{mx},{my}",
-        "active_sessions": len(_active_sessions),
+        "active_users": n,
+        "users": users,
     }
 
 
@@ -1061,7 +1131,7 @@ async def health():
 # ════════════════════════════════════════════════════════════════
 
 async def _cleanup_tmp():
-    """ينظّف /tmp كل 5 دقائق لمنع امتلاء القرص في HuggingFace."""
+    """ينظّف /tmp كل 5 دقائق."""
     while True:
         await asyncio.sleep(300)
         try:
@@ -1073,13 +1143,42 @@ async def _cleanup_tmp():
             print(f"[cleanup] {e}")
 
 
+async def _cleanup_idle_sessions():
+    """
+    يُزيل sessions المستخدمين غير النشطين (لا اتصال منذ أكثر من ساعة)
+    لتحرير الـ displays والذاكرة.
+    """
+    while True:
+        await asyncio.sleep(1800)  # كل 30 دقيقة
+        now = time.time()
+        to_remove = []
+        with _display_lock:
+            for uid, sess in list(_user_displays.items()):
+                if sess.get("active_ws"):
+                    continue  # لا تحذف sessions النشطة
+                if now - sess.get("created", now) > 3600:  # أكثر من ساعة
+                    to_remove.append((uid, sess))
+
+        for uid, sess in to_remove:
+            print(f"[cleanup] 🗑️ Removing idle session for '{uid}' on {sess['display']}")
+            _kill_proc(sess.get("browser_proc"))
+            _kill_proc(sess.get("xvfb_proc"))
+            _kill_display_processes(sess["display"])
+            with _display_lock:
+                _user_displays.pop(uid, None)
+                try:
+                    _display_numbers.discard(int(sess["display"].lstrip(":")))
+                except Exception:
+                    pass
+
+
 @app.on_event("startup")
 async def startup():
-    # تشغيل Xvfb المشترك
-    await asyncio.to_thread(_ensure_xvfb)
-    # تشغيل التنظيف الدوري
     asyncio.create_task(_cleanup_tmp())
-    print("✅ Z Computer Mode v8 ready")
+    asyncio.create_task(_cleanup_idle_sessions())
+    print("✅ Z Computer Mode v11 ready — Per-User Isolated Displays")
+    print(f"   Display range: :{DISPLAY_BASE} → :{DISPLAY_MAX}")
+    print(f"   Connect: wss://your-space.hf.space/ws?user_id=EMAIL")
 
 
 if __name__ == "__main__":