Update app.py

app.py

@@ -1,40 +1,48 @@
 """
-THE Z AI — Computer Mode Server v8 — STABLE & FAST
-====================================================
-التحسينات الجوهرية في v8:
-  1. Xvfb واحد فقط ثابت على :99 — يُشغَّل مرة واحدة عند بدء السيرفر
-     بدلاً من Xvfb جديد لكل اتصال (كان يفشل في HuggingFace)
-  2. عزل المستخدمين عبر profile منفصل لكل جلسة (firefox --profile /tmp/profile_N)
-     بدلاً من عزل DISPLAY منفصل (الذي كان غير ممكن في HF)
-  3. مجموعة screenshot موثوقة: scrot → import → ffmpeg → PIL Xlib
-     مع retry تلقائي وتحقق من أن الصورة ليست سوداء تماماً (black_screen_check)
-  4. Playwright اختياري — إذا كان متاحاً يُستخدم للتحكم الأسرع
-     وإن لم يكن متاحاً، يُعود لـ xdotool كالمعتاد
-  5. WebSocket heartbeat — ping/pong كل 20 ثانية لمنع قطع الاتصال
-  6. Screenshot delta compression — إذا الصورة لم تتغير بأكثر من 3% لا تُرسل
-     (يوفر bandwidth خصوصاً عند عمليات keyboard_type)
-  7. Frame buffer مشترك محمي بـ asyncio.Lock — لا تعارض بين الجلسات
-  8. Rate limiting لـ screenshot: لا أكثر من 1 كل 0.3 ثانية لنفس الجلسة
-  9. auto_shot_grid يُنفَّذ في background task (لا يُجمّد الـ action loop)
-  10. أوامر terminal تُنفَّذ في asyncio.Semaphore(4) لمنع تزاحم العمليات
-  11. SafeSearch مفروضة على كل URL في كل مكان
-  12. تنظيف /tmp تلقائي كل 5 دقائق (يمنع امتلاء القرص في HF المجاني)
+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 دقائق
 """
 
 import asyncio
 import base64
-import contextvars
 import hashlib
 import io
 import json
 import os
 import re
 import subprocess
-import tempfile
 import time
 import urllib.parse
-import uuid
-from pathlib import Path
 
 from fastapi import FastAPI, WebSocket, WebSocketDisconnect
 from fastapi.middleware.cors import CORSMiddleware
@@ -52,15 +60,7 @@ os.environ["DISPLAY"] = SHARED_DISPLAY
 # semaphore للتحكم في عدد عمليات terminal المتوازية
 _terminal_sem = asyncio.Semaphore(4)
 
-# lock لحماية كتابة ملفات /tmp من التعارض
-_tmp_lock = asyncio.Lock()
-
-# ── contextvar للـ profile الخاص بالجلسة ──
-_current_profile: contextvars.ContextVar[str] = contextvars.ContextVar(
-    "_current_profile", default=""
-)
-
-# ── تخزين الجلسات: session_id → {profile_dir, last_screenshot_ts, last_frame_hash} ──
+# ── تخزين الجلسات: session_id → {last_bg_shot_ts, last_bg_hash, browser_proc} ──
 _active_sessions: dict[int, dict] = {}
 _sessions_lock = asyncio.Lock()
 
@@ -138,30 +138,25 @@ print(f"🌐 Browser: {BROWSER}")
 
 async def create_session(ws: WebSocket) -> dict:
     """
-    ينشئ profile firefox منفصل لهذا المستخدم.
-    كل مستخدم يحصل على profile نظيف خاص به في /tmp/zpc_XXXXX/
-    لمنع التداخل بين جلسات متعددة على نفس DISPLAY.
+    ينشئ session بسيطة لهذا المستخدم.
+    لا profile منفصل — Firefox يعمل بـ --no-remote فقط للعزل.
     """
     sid = id(ws)
-    profile_dir = f"/tmp/zpc_{sid}"
-    os.makedirs(profile_dir, exist_ok=True)
-
     sess = {
         "id": sid,
-        "profile": profile_dir,
-        "last_shot_ts": 0.0,
-        "last_frame_hash": "",
+        "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} profile={profile_dir}")
+    print(f"[session] ✅ Created session {sid}")
     return sess
 
 
 async def destroy_session(ws: WebSocket):
-    """يحذف profile الجلسة وينظّف الموارد."""
+    """يحرر موارد الجلسة عند انقطاع الاتصال."""
     sid = id(ws)
     async with _sessions_lock:
         sess = _active_sessions.pop(sid, None)
@@ -169,7 +164,6 @@ async def destroy_session(ws: WebSocket):
         return
 
     def _cleanup():
-        # أغلق المتصفح إذا كان مفتوحاً
         bp = sess.get("browser_proc")
         if bp:
             try:
@@ -180,27 +174,15 @@ async def destroy_session(ws: WebSocket):
                     bp.kill()
                 except Exception:
                     pass
-        # احذف profile
-        import shutil
-        try:
-            shutil.rmtree(sess["profile"], ignore_errors=True)
-        except Exception:
-            pass
 
     await asyncio.to_thread(_cleanup)
     print(f"[session] 🗑️ Destroyed session {sid}")
 
 
-def get_browser_cmd(url: str = "", profile: str = "") -> list:
-    """يبني أمر فتح المتصفح مع profile منفصل لكل مستخدم."""
-    cmd = [BROWSER]
-    if profile:
-        cmd += ["--profile", profile]
-    cmd += ["--no-remote"]
-    if url:
-        cmd += [url]
-    else:
-        cmd += ["about:blank"]
+def get_browser_cmd(url: str = "") -> list:
+    """يبني أمر فتح المتصفح بدون profile — --no-remote يمنع التداخل."""
+    cmd = [BROWSER, "--no-remote"]
+    cmd.append(url if url else "about:blank")
     return cmd
 
 
@@ -224,9 +206,8 @@ def _is_black_screen(img) -> bool:
 
 def _capture_raw() -> tuple:
     """
-    يلتقط الشاشة بـ 4 طرق متسلسلة.
+    يلتقط الشاشة بـ 4 طرق متسلسلة مع retry إذا الصورة سوداء.
     يُعيد (PIL.Image | None, width, height).
-    ملاحظة: كل ملفات /tmp تُحذف دائماً (finally block).
     """
     from PIL import Image
     env = {**os.environ, "DISPLAY": SHARED_DISPLAY}
@@ -257,93 +238,96 @@ def _capture_raw() -> tuple:
             except Exception:
                 pass
 
-    try:
-        # ── Method 1: scrot (fastest) ──────────────────────
-        p1 = f"{tmp_base}_scrot.png"
-        created_files.append(p1)
+    # نحاول 3 مرات إذا الصورة سوداء (مثلاً: Firefox لا يزال يتحمّل)
+    for attempt in range(3):
+        if attempt > 0:
+            time.sleep(0.8)
+            print(f"[cap] retry attempt {attempt+1} (black screen)")
         try:
-            r = 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("[cap] ✅ scrot")
-                return img, w, h
-            if img:
-                print("[cap] ⚠️ scrot got black screen — trying next")
-        except Exception as e:
-            print(f"[cap] scrot: {e}")
+            # ── 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
+                )
+                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}")
 
-        # ── Method 2: ImageMagick import ────────────────────
-        p2 = f"{tmp_base}_im.png"
-        created_files.append(p2)
-        try:
-            r = 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("[cap] ✅ ImageMagick import")
-                return img, w, h
-        except Exception as e:
-            print(f"[cap] import: {e}")
+            # ── 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
+                )
+                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}")
 
-        # ── Method 3: ffmpeg x11grab ────────────────────────
-        p3 = f"{tmp_base}_ff.png"
-        created_files.append(p3)
-        try:
-            sw, sh = _get_screen_size()
-            r = subprocess.run([
-                "ffmpeg", "-y", "-f", "x11grab",
-                "-video_size", f"{sw}x{sh}",
-                "-i", SHARED_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("[cap] ✅ ffmpeg")
-                return img, w, h
-        except Exception as e:
-            print(f"[cap] ffmpeg: {e}")
+            # ── Method 3: ffmpeg x11grab ──────────────────────
+            p3 = f"{tmp_base}_a{attempt}_ff.png"
+            created_files.append(p3)
+            try:
+                sw, sh = _get_screen_size()
+                subprocess.run([
+                    "ffmpeg", "-y", "-f", "x11grab",
+                    "-video_size", f"{sw}x{sh}",
+                    "-i", SHARED_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}")
 
-        # ── Method 4: python-xlib ────────────────────────────
-        try:
-            from Xlib import display as Xdisp, X
-            import struct
-            xd = Xdisp.Display(SHARED_DISPLAY)
-            root = xd.screen().root
-            geom = root.get_geometry()
-            w, h = geom.width, geom.height
-            raw = root.get_image(0, 0, w, h, X.ZPixmap, 0xFFFFFFFF)
-            data = raw.data
-            pixels = bytearray(len(data) // 4 * 3)
-            for i in range(0, len(data) - 3, 4):
-                b, g, r_c = data[i], data[i+1], data[i+2]
-                j = (i // 4) * 3
-                pixels[j], pixels[j+1], pixels[j+2] = r_c, g, b
-            from PIL import Image as PILImg
-            img = PILImg.frombytes("RGB", (w, h), bytes(pixels))
-            if not _is_black_screen(img):
-                print("[cap] ✅ xlib")
-                return img, w, h
-        except Exception as e:
-            print(f"[cap] xlib: {e}")
-
-        # ── Fallback: placeholder ────────────────────────────
-        print("[cap] ⚠️ All methods failed or black — returning placeholder")
-        from PIL import Image as PILImg, ImageDraw
-        sw, sh = _get_screen_size()
-        img = PILImg.new("RGB", (sw or 1920, sh or 1080), (15, 15, 25))
-        draw = ImageDraw.Draw(img)
-        draw.rectangle([(0, 0), (sw, 50)], fill=(30, 30, 60))
-        draw.text((10, 15), f"⚠️ Screenshot failed — DISPLAY={SHARED_DISPLAY}", fill=(255, 100, 100))
-        draw.text((10, 35), f"Methods tried: scrot, import, ffmpeg, xlib", fill=(120, 120, 120))
-        return img, sw or 1920, sh or 1080
+            # ── Method 4: python-xlib ─────────────────────────
+            try:
+                from Xlib import display as Xdisp, X
+                xd = Xdisp.Display(SHARED_DISPLAY)
+                root = xd.screen().root
+                geom = root.get_geometry()
+                w, h = geom.width, geom.height
+                raw = root.get_image(0, 0, w, h, X.ZPixmap, 0xFFFFFFFF)
+                data = raw.data
+                pixels = bytearray(len(data) // 4 * 3)
+                for i in range(0, len(data) - 3, 4):
+                    b, g, r_c = data[i], data[i+1], data[i+2]
+                    j = (i // 4) * 3
+                    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}")
 
-    finally:
-        _cleanup_files()
+        finally:
+            _cleanup_files()
+
+    # إذا فشلت كل المحاولات — placeholder واضح
+    print("[cap] ⚠️ All methods failed or black — placeholder")
+    from PIL import Image as PILImg, ImageDraw
+    sw, sh = _get_screen_size()
+    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))
+    return img, sw or 1920, sh or 1080
 
 
 def _get_screen_size() -> tuple:
@@ -663,29 +647,33 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
         except Exception:
             pass
 
-    async def shot(label: str = "", delay: float = 0.5,
-                   force_mx: int | None = None, force_my: int | None = None):
-        """لقطة شاشة مع grid — مع rate limiting و delta suppression."""
+    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.
+        لا يُرسل إذا الصورة لم تتغير — المستخدم يرى التحديث عند الطلب الصريح.
+        """
         await asyncio.sleep(delay)
 
-        # Rate limit: لا أكثر من لقطة كل 0.3 ثانية
+        # Rate limit: لا أكثر من لقطة كل 0.3 ثانية لنفس الجلسة
         now = time.time()
-        if now - sess.get("last_shot_ts", 0) < 0.3:
-            await asyncio.sleep(0.3 - (now - sess["last_shot_ts"]))
+        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
         )
-        sess["last_shot_ts"] = time.time()
+        sess["last_bg_shot_ts"] = time.time()
 
         if not result["data"]:
             return
 
         # Delta suppression: لا ترسل إذا الصورة لم تتغير
         fh = _frame_hash(result["data"])
-        if fh == sess.get("last_frame_hash", "") and not label.startswith("force"):
-            return
-        sess["last_frame_hash"] = fh
+        if fh == sess.get("last_bg_hash", ""):
+            return  # لم تتغير — لا ترسل
+        sess["last_bg_hash"] = fh
 
         await send({
             "type": "screenshot",
@@ -700,14 +688,23 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
             "has_grid": True,
         })
 
-    # ── screenshot ───────────────────────────────────────────
-    if action == "screenshot":
-        sess["last_frame_hash"] = ""  # force send
+    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)
+        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,
             "screen_width": result["width"],
             "screen_height": result["height"],
             "mouse_x": result["mouse_x"],
@@ -715,6 +712,10 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
             "has_grid": True,
         })
 
+    # ── screenshot (صريح من الـ HTML — يُرسل دائماً بدون تأخير) ──────
+    if action == "screenshot":
+        await shot_explicit("explicit screenshot")
+
     # ── terminal ─────────────────────────────────────────────
     elif action == "terminal":
         cmd = data.get("cmd", "")
@@ -729,14 +730,15 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
             "stderr": res.get("stderr", ""),
             "returncode": res["returncode"],
         })
-        asyncio.create_task(shot(f"after: {cmd[:40]}", delay=0.4))
+        # 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 send({"type": "ack", "action": "mouse_move", "x": x, "y": y})
-        asyncio.create_task(shot(f"move ({x},{y})", delay=0.2, force_mx=x, force_my=y))
+        asyncio.create_task(shot_bg(f"move ({x},{y})", delay=0.2, force_mx=x, force_my=y))
 
     # ── mouse_click ──────────────────────────────────────────
     elif action == "mouse_click":
@@ -751,7 +753,7 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
             await xdo(["click", btn])
         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(f"click {btn_name} ({x},{y})", delay=0.5, force_mx=x, force_my=y))
+        asyncio.create_task(shot_bg(f"click {btn_name} ({x},{y})", delay=0.5, force_mx=x, force_my=y))
 
     # ── mouse_drag ───────────────────────────────────────────
     elif action == "mouse_drag":
@@ -764,7 +766,7 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
         await asyncio.sleep(0.1)
         await xdo(["mouseup", "1"])
         await send({"type": "ack", "action": "mouse_drag"})
-        asyncio.create_task(shot("after drag", delay=0.4, force_mx=x2, force_my=y2))
+        asyncio.create_task(shot_bg("after drag", delay=0.4, force_mx=x2, force_my=y2))
 
     # ── keyboard_type ────────────────────────────────────────
     elif action == "keyboard_type":
@@ -772,7 +774,7 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
         if text:
             res = await type_smart(text)
             await send({"type": "ack", "action": "keyboard_type", "method": res["method"]})
-        asyncio.create_task(shot("after type", delay=0.5))
+        asyncio.create_task(shot_bg("after type", delay=0.5))
 
     # ── keyboard_hotkey ──────────────────────────────────────
     elif action == "keyboard_hotkey":
@@ -780,7 +782,7 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
         if keys:
             await xdo(["key", "--clearmodifiers", "+".join(keys)])
         await send({"type": "ack", "action": "keyboard_hotkey", "keys": keys})
-        asyncio.create_task(shot("after hotkey", delay=0.4))
+        asyncio.create_task(shot_bg("after hotkey", delay=0.4))
 
     # ── keyboard_press ───────────────────────────────────────
     elif action == "keyboard_press":
@@ -788,7 +790,7 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
         if key:
             await xdo(["key", "--clearmodifiers", key])
         await send({"type": "ack", "action": "keyboard_press"})
-        asyncio.create_task(shot("after key", delay=0.4))
+        asyncio.create_task(shot_bg("after key", delay=0.4))
 
     # ── scroll ───────────────────────────────────────────────
     elif action == "scroll":
@@ -800,7 +802,7 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
             await xdo(["click", btn])
             await asyncio.sleep(0.025)
         await send({"type": "ack", "action": "scroll", "clicks": clicks})
-        asyncio.create_task(shot("after scroll", delay=0.4))
+        asyncio.create_task(shot_bg("after scroll", delay=0.4))
 
     # ── clipboard_write ──────────────────────────────────────
     elif action == "clipboard_write":
@@ -829,7 +831,7 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
             await asyncio.sleep(0.1)
             await xdo(["key", "--clearmodifiers", "ctrl+v"])
         await send({"type": "ack", "action": "paste"})
-        asyncio.create_task(shot("after paste", delay=0.5))
+        asyncio.create_task(shot_bg("after paste", delay=0.5))
 
     # ── open_app ─────────────────────────────────────────────
     elif action == "open_app":
@@ -838,15 +840,14 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
             await send({"type": "ack", "action": "open_app"})
             return
 
-        # أضف profile للـ firefox إذا لم يكن محدداً
-        profile = sess.get("profile", "")
-        if profile and any(b in cmd for b in ("firefox", "chromium")):
-            if "--profile" not in cmd:
-                cmd = cmd.replace(BROWSER, f"{BROWSER} --profile {profile}", 1)
-
-        # نظّف lock files
+        # نظّف lock files قبل فتح Firefox (يمنع "already running" dialog)
         if "firefox" in cmd.lower():
-            await run_cmd("rm -f ~/.mozilla/firefox/*/lock ~/.mozilla/firefox/*/.parentlock 2>/dev/null", 3)
+            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
+            )
 
         env = {**os.environ, "DISPLAY": SHARED_DISPLAY}
         proc = subprocess.Popen(
@@ -857,22 +858,34 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
             sess["browser_proc"] = proc
 
         await send({"type": "ack", "action": "open_app", "cmd": cmd})
-        # screenshot مبكر ثم واحد بعد التحميل
-        asyncio.create_task(shot("opening app (2s)", delay=2.0))
-        asyncio.create_task(shot("app loaded (7s)", delay=7.0))
+        async def _open_app_shots():
+            await asyncio.sleep(3.0)
+            await shot_explicit("app opening 3s")
+            await asyncio.sleep(5.0)
+            await shot_explicit("app loaded 8s")
+        asyncio.create_task(_open_app_shots())
 
     # ── open_browser ─────────────────────────────────────────
     elif action == "open_browser":
         url = _safe_search(data.get("url", "") or "about:blank")
-        profile = sess.get("profile", "")
-        cmd = get_browser_cmd(url, profile)
+        # نظّف أي 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
+        )
+        cmd = get_browser_cmd(url)
         env = {**os.environ, "DISPLAY": SHARED_DISPLAY}
-        await run_cmd("rm -f ~/.mozilla/firefox/*/lock ~/.mozilla/firefox/*/.parentlock 2>/dev/null", 3)
         proc = subprocess.Popen(cmd, env=env, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
         sess["browser_proc"] = proc
         await send({"type": "ack", "action": "open_browser", "url": url})
-        asyncio.create_task(shot("browser opening (2s)", delay=2.0))
-        asyncio.create_task(shot("browser loaded (7s)", delay=7.0))
+        async def _open_browser_shots():
+            await asyncio.sleep(3.0)
+            await shot_explicit("browser opening 3s")
+            await asyncio.sleep(6.0)
+            await shot_explicit("browser loaded 9s")
+        asyncio.create_task(_open_browser_shots())
 
     # ── open_tab ─────────────────────────────────────────────
     elif action == "open_tab":
@@ -885,25 +898,25 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
         await asyncio.sleep(0.2)
         await xdo(["key", "--clearmodifiers", "Return"])
         await send({"type": "ack", "action": "open_tab", "url": url})
-        asyncio.create_task(shot("after open_tab", delay=1.5))
+        asyncio.create_task(shot_bg("after open_tab", delay=1.5))
 
     # ── close_tab ────────────────────────────────────────────
     elif action == "close_tab":
         await xdo(["key", "--clearmodifiers", "ctrl+w"])
         await send({"type": "ack", "action": "close_tab"})
-        asyncio.create_task(shot("after close_tab", delay=0.5))
+        asyncio.create_task(shot_bg("after close_tab", delay=0.5))
 
     # ── browser_back ─────────────────────────────────────────
     elif action == "browser_back":
         await xdo(["key", "--clearmodifiers", "alt+Left"])
         await send({"type": "ack", "action": "browser_back"})
-        asyncio.create_task(shot("after back", delay=0.8))
+        asyncio.create_task(shot_bg("after back", delay=0.8))
 
     # ── browser_forward ───────────���──────────────────────────
     elif action == "browser_forward":
         await xdo(["key", "--clearmodifiers", "alt+Right"])
         await send({"type": "ack", "action": "browser_forward"})
-        asyncio.create_task(shot("after forward", delay=0.8))
+        asyncio.create_task(shot_bg("after forward", delay=0.8))
 
     # ── browser_search ───────────────────────────────────────
     elif action == "browser_search":
@@ -914,7 +927,7 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
         await asyncio.sleep(0.15)
         await xdo(["key", "--clearmodifiers", "Return"])
         await send({"type": "ack", "action": "browser_search"})
-        asyncio.create_task(shot("after search", delay=1.5))
+        asyncio.create_task(shot_bg("after search", delay=1.5))
 
     # ── screen_info ──────────────────────────────────────────
     elif action == "screen_info":
@@ -963,10 +976,10 @@ async def websocket_endpoint(ws: WebSocket):
             "browser": BROWSER,
             "display": SHARED_DISPLAY,
             "session_id": id(ws),
-            "msg": f"Z Computer Mode v8 | Browser: {BROWSER} | Screen: {w}x{h}",
+            "msg": f"Z Computer Mode v10 | Browser: {BROWSER} | Screen: {w}x{h}",
         }, ensure_ascii=False))
 
-        # لقطة شاشة أولية
+        # لقطة شاشة أولية — دائماً تُرسل بغض النظر عن أي شيء
         result = await asyncio.to_thread(capture_with_grid, 0.65, 72)
         if result["data"]:
             await ws.send_text(json.dumps({
@@ -980,7 +993,7 @@ async def websocket_endpoint(ws: WebSocket):
                 "mouse_y": result["mouse_y"],
                 "has_grid": True,
             }, ensure_ascii=False))
-            sess["last_frame_hash"] = _frame_hash(result["data"])
+            sess["last_bg_hash"] = _frame_hash(result["data"])
 
     except Exception as e:
         print(f"[ws] init error: {e}")
@@ -1052,15 +1065,10 @@ async def _cleanup_tmp():
     while True:
         await asyncio.sleep(300)
         try:
-            r = subprocess.run(
+            subprocess.run(
                 ["find", "/tmp", "-name", "zss_*", "-mmin", "+10", "-delete"],
                 capture_output=True, timeout=10
             )
-            r2 = subprocess.run(
-                ["find", "/tmp", "-name", "zpc_*", "-mmin", "+60",
-                 "-not", "-newer", "/tmp", "-delete"],
-                capture_output=True, timeout=10
-            )
         except Exception as e:
             print(f"[cleanup] {e}")