Update app.py

app.py

@@ -74,6 +74,17 @@ def _detect_browser() -> str:
 BROWSER = _detect_browser()
 print(f"🌐 Browser: {BROWSER}")
 
+# ── CLI flags ثابتة تُضاف لكل تشغيل Firefox ──
+# تسرّع الإقلاع (لا GPU فيزيائي حقيقي في Xvfb فلا داعي لمحاولة
+# التسريع المرئي الذي يفشل دائماً هنا ويسبّب تأخيراً في الإقلاع)،
+# وتمنع أي nag screens أو crash-reporter windows من الظهور.
+FIREFOX_CLI_FLAGS = ["--no-remote", "--new-instance"]
+FIREFOX_ENV_EXTRA = {
+    # يمنع محاولات تسريع GPU غير المتوفرة في Xvfb من إبطاء الإقلاع
+    "MOZ_DISABLE_GPU_SANDBOX": "1",
+    "MOZ_ACCELERATED": "0",
+}
+
 # ════════════════════════════════════════════════════════════════
 # ── Firefox Profile (per-user, isolated, crash-recovery DISABLED) ─
 # ════════════════════════════════════════════════════════════════
@@ -125,6 +136,38 @@ user_pref("datareporting.policy.dataSubmissionEnabled", false);
 user_pref("app.normandy.enabled", false);
 user_pref("app.update.enabled", false);
 user_pref("app.update.auto", false);
+// ── إصلاحات تجمد التحميل ("Connecting to ... تبقى للأبد") ──
+// السبب الغالب على سيرفرات مجانية/container: محاولة IPv6 أولاً (غير
+// مدعوم فعلياً على أغلب مزودي Render/HuggingFace المجانية) قبل الرجوع
+// لـ IPv4 بعد timeout طويل جداً (قد يصل 20-30 ثانية لكل طلب DNS)،
+// وهذا بالضبط السبب الذي يظهر كشاشة "Connecting..." معلقة لا تتقدم أبداً.
+user_pref("network.dns.disableIPv6", true);
+user_pref("network.http.fast-fallback-to-IPv4", true);
+// تقليل مهلة connect الإجمالية لكل طلب من 15 ثانية (الافتراضي) إلى 8 ثوانٍ
+// — أفضل أن يفشل الطلب بسرعة ويقرر الذكاء الاصطناعي بديلاً من أن يبقى عالقاً طويلاً.
+user_pref("network.http.connection-timeout", 8);
+user_pref("network.http.response.timeout", 12);
+// تعطيل predictive prefetching/speculative connect التي تستهلك عرض حزمة على
+// سيرفر محدود الموارد بدون فائدة حقيقية هنا.
+user_pref("network.dns.disablePrefetch", true);
+user_pref("network.prefetch-next", false);
+user_pref("network.predictor.enabled", false);
+user_pref("network.http.speculative-parallel-limit", 0);
+// تعطيل safebrowsing الذي يستدعي طلبات خارجية إضافية عند فتح كل صفحة
+// (يُبطئ التحميل أو يعلقه لو الطلب لقوائم Google فشل أو استغرق).
+user_pref("browser.safebrowsing.malware.enabled", false);
+user_pref("browser.safebrowsing.phishing.enabled", false);
+user_pref("browser.safebrowsing.downloads.enabled", false);
+user_pref("browser.safebrowsing.provider.google4.updateURL", "");
+user_pref("browser.safebrowsing.provider.google.updateURL", "");
+// تعطيل telemetry/captive-portal checks التي تفتح اتصالات خلفية غير ضرورية عند الإقلاع
+user_pref("network.captive-portal-service.enabled", false);
+user_pref("network.connectivity-service.enabled", false);
+user_pref("toolkit.telemetry.server", "");
+// تقليل عدد اتصالات HTTP المتزامنة لكل دومين — يقلل الضغط على شبكة محدودة
+// النطاق للسيرفرات المجانية ويقلل احتمال التعلق.
+user_pref("network.http.max-persistent-connections-per-server", 4);
+user_pref("network.http.max-connections", 48);
 """
 
 def _ensure_firefox_profile(user_id: str, display: str) -> str:
@@ -192,8 +235,12 @@ def _start_xvfb(display: str) -> "subprocess.Popen | None":
         pass
 
     try:
+        # ── دقة 1280x800 بدل 1920x1080 ──────────────────────────────
+        # هذا يقلل حجم بيانات كل لقطة شاشة بنسبة ~60%، وبالتالي يسرّع كل
+        # مراحل الالتقاط والترميز بشكل كبير على سيرفر بموارد محدودة.
+        # نفس الدقة المستخدمة في التطبيقات المرجعية لـ computer-use.
         proc = subprocess.Popen(
-            ["Xvfb", display, "-screen", "0", "1920x1080x24",
+            ["Xvfb", display, "-screen", "0", "1280x800x24",
              "-nolisten", "tcp", "-ac"],
             stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
         )
@@ -434,170 +481,90 @@ def _load_capture_image(path: str):
         return None, 0, 0
 
 
-def _capture_via_x11_stack(display: str):
-    """الطريقة الأولى: scrot → ImageMagick import → ffmpeg x11grab → python-xlib."""
+def _capture_via_import_pipe(display: str):
+    """
+    الطريقة الأساسية والوحيدة: `import -window root` مع الإخراج مباشرة
+    عبر stdout (pipe) — بدون أي ملف مؤقت على القرص. أسرع بشكل ملحوظ من
+    الكتابة لملف ثم إعادة قراءته، خصوصاً على تخزين شبكي بطيء.
+    """
     from PIL import Image
     env = {**os.environ, "DISPLAY": display}
-    ts = int(time.time() * 1000)
-    disp_safe = display.replace(":", "")
-    tmp_base = f"/tmp/zss_{disp_safe}_{ts}"
-    created_files = []
-
-    def _cleanup_files():
-        for p in created_files:
-            try:
-                if p and os.path.exists(p):
-                    os.unlink(p)
-            except Exception:
-                pass
-
     try:
-        p1 = f"{tmp_base}_scrot.png"
-        created_files.append(p1)
-        try:
-            subprocess.run(["scrot", "-q", "95", p1], env=env, timeout=8, capture_output=True)
-            img, w, h = _load_capture_image(p1)
-            if img and not _is_black_screen(img):
-                return img, w, h
-        except Exception as e:
-            print(f"[cap:{display}] scrot: {e}")
-
-        p2 = f"{tmp_base}_im.png"
-        created_files.append(p2)
-        try:
-            subprocess.run(["import", "-window", "root", "-silent", p2], env=env, timeout=10, capture_output=True)
-            img, w, h = _load_capture_image(p2)
-            if img and not _is_black_screen(img):
-                return img, w, h
-        except Exception as e:
-            print(f"[cap:{display}] import: {e}")
-
-        p3 = f"{tmp_base}_ff.png"
-        created_files.append(p3)
-        try:
-            sw, sh = _get_screen_size(display)
-            subprocess.run([
-                "ffmpeg", "-y", "-f", "x11grab",
-                "-video_size", f"{sw}x{sh}",
-                "-i", display,
-                "-vframes", "1", "-q:v", "1", p3
-            ], env=env, timeout=12, capture_output=True)
-            img, w, h = _load_capture_image(p3)
-            if img and not _is_black_screen(img):
-                return img, w, h
-        except Exception as e:
-            print(f"[cap:{display}] ffmpeg: {e}")
-
-        try:
-            from Xlib import display as Xdisp, X
-            xd = Xdisp.Display(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):
-                return img, w, h
-        except Exception as e:
-            print(f"[cap:{display}] xlib: {e}")
-
+        r = subprocess.run(
+            ["import", "-window", "root", "-silent", "png:-"],
+            env=env, timeout=6, capture_output=True
+        )
+        if r.returncode != 0 or not r.stdout or len(r.stdout) < 500:
+            return None, 0, 0
+        img = Image.open(io.BytesIO(r.stdout)).convert("RGB")
+        w, h = img.size
+        if w < 100 or h < 100:
+            return None, 0, 0
+        return img, w, h
+    except FileNotFoundError:
+        print(f"[cap:{display}] import (ImageMagick) not installed")
         return None, 0, 0
-    finally:
-        _cleanup_files()
-
-
-def _capture_via_xwd(display: str):
-    """الطريقة الثانية: xwd ثم convert إلى PNG."""
-    env = {**os.environ, "DISPLAY": display}
-    ts = int(time.time() * 1000)
-    disp_safe = display.replace(":", "")
-    xwd_path = f"/tmp/zss_{disp_safe}_{ts}.xwd"
-    png_path = f"/tmp/zss_{disp_safe}_{ts}.png"
-    try:
-        with open(xwd_path, "wb") as f:
-            subprocess.run(["xwd", "-root", "-silent"], env=env, stdout=f, stderr=subprocess.PIPE, timeout=12)
-        subprocess.run(["convert", xwd_path, png_path], env=env, capture_output=True, timeout=15)
-        img, w, h = _load_capture_image(png_path)
-        if img and not _is_black_screen(img):
-            return img, w, h
-    except FileNotFoundError as e:
-        print(f"[cap:{display}] xwd/convert not found: {e}")
     except Exception as e:
-        print(f"[cap:{display}] xwd: {e}")
-    finally:
-        for p in (xwd_path, png_path):
-            try:
-                if os.path.exists(p):
-                    os.unlink(p)
-            except Exception:
-                pass
-    return None, 0, 0
+        print(f"[cap:{display}] import-pipe: {e}")
+        return None, 0, 0
 
 
-def _capture_via_pyscreenshot(display: str):
-    """الطريقة الثالثة: pyscreenshot backend من داخل Python."""
-    ts = int(time.time() * 1000)
-    disp_safe = display.replace(":", "")
-    png_path = f"/tmp/zss_{disp_safe}_{ts}_pyshot.png"
-    env = {**os.environ, "DISPLAY": display}
+def _capture_via_xlib_direct(display: str):
+    """
+    خط الدفاع الثاني والأخير: قراءة X11 framebuffer مباشرة عبر
+    python-xlib، بدون subprocess إطلاقاً (أسرع من أي أداة خارجية،
+    ويعمل حتى لو ImageMagick غير مثبّت على السيرفر).
+    """
+    from PIL import Image
     try:
-        code = """import sys
-from pyscreenshot import grab
-out = sys.argv[1]
-img = grab()
-img.save(out)
-"""
-        subprocess.run([sys.executable, "-c", code, png_path], env=env, capture_output=True, timeout=18)
-        img, w, h = _load_capture_image(png_path)
-        if img and not _is_black_screen(img):
-            return img, w, h
-    except FileNotFoundError as e:
-        print(f"[cap:{display}] pyscreenshot not available: {e}")
+        from Xlib import display as Xdisp, X
+        xd = Xdisp.Display(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)
+        img = Image.frombuffer("RGB", (w, h), raw.data, "raw", "BGRX", 0, 1)
+        xd.close()
+        return img, w, h
     except Exception as e:
-        print(f"[cap:{display}] pyscreenshot: {e}")
-    finally:
-        try:
-            if os.path.exists(png_path):
-                os.unlink(png_path)
-        except Exception:
-            pass
-    return None, 0, 0
+        print(f"[cap:{display}] xlib-direct: {e}")
+        return None, 0, 0
 
 
 def _capture_raw(display: str) -> tuple:
-    """يلتقط الشاشة من display محدد عبر 3 طرق مستقلة."""
-    for attempt in range(3):
-        if attempt > 0:
-            time.sleep(0.8)
-            print(f"[cap:{display}] retry attempt {attempt+1}")
-        for method_name, method in (
-            ("x11-stack", _capture_via_x11_stack),
-            ("xwd", _capture_via_xwd),
-            ("pyscreenshot", _capture_via_pyscreenshot),
-        ):
+    """
+    يلتقط الشاشة بأسرع طريقة موثوقة: import-pipe أولاً (سريعة جداً)،
+    وعند فشلها فقط xlib-direct كبديل واحد. بحد أقصى محاولتين سريعتين
+    لكل طريقة (وليس 9 محاولات كالسابق) — لأن كلا الطريقتين إما تنجحان
+    فوراً أو تفشلان لسبب دائم، وإعادة المحاولة أكثر من مرتين لا تُغيّر
+    النتيجة، فقط تُبطئ الاستجابة.
+    """
+    for method_name, method in (
+        ("import-pipe", _capture_via_import_pipe),
+        ("xlib-direct", _capture_via_xlib_direct),
+    ):
+        for attempt in range(2):
             try:
                 img, w, h = method(display)
                 if img and not _is_black_screen(img):
-                    print(f"[cap:{display}] ✅ {method_name} succeeded on attempt {attempt+1}")
+                    if attempt > 0:
+                        print(f"[cap:{display}] ✅ {method_name} succeeded on retry")
                     return img, w, h
             except Exception as e:
                 print(f"[cap:{display}] {method_name}: {e}")
+            if attempt == 0:
+                time.sleep(0.3)
 
     print(f"[cap:{display}] ⚠️ All methods failed — placeholder")
     from PIL import Image as PILImg, ImageDraw
     sw, sh = _get_screen_size(display)
-    img = PILImg.new("RGB", (sw or 1920, sh or 1080), (15, 20, 40))
+    img = PILImg.new("RGB", (sw or 1280, sh or 800), (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={display}", fill=(255, 120, 80))
-    draw.text((10, 32), "Methods: x11-stack, xwd+convert, pyscreenshot (3 attempts)", fill=(130, 130, 150))
-    return img, sw or 1920, sh or 1080
+    draw.text((10, 32), "Methods tried: import-pipe, xlib-direct", fill=(130, 130, 150))
+    return img, sw or 1280, sh or 800
+
 
 def _get_screen_size(display: str) -> tuple:
     try:
@@ -609,7 +576,7 @@ def _get_screen_size(display: str) -> tuple:
         parts = r.stdout.strip().split()
         return int(parts[0]), int(parts[1])
     except Exception:
-        return 1920, 1080
+        return 1280, 800
 
 
 def _get_mouse_pos(display: str) -> tuple:
@@ -637,15 +604,15 @@ def _draw_mouse_marker(draw, msx, msy, color=(255, 50, 50, 240)):
 
 def _render_grid_variant(base_img, ow, oh, sw, sh, mx, my, display,
                          grid_step: int, line_color: tuple, label_every: int,
-                         major_only_labels: bool = True) -> "Image.Image":
+                         major_only_labels: bool = True):
     """
     يرسم نسخة شبكة إحداثيات واحدة فوق نسخة من الصورة الأساسية.
       grid_step        → المسافة بالبكسل الحقيقي بين كل خط شبكة.
-      line_color       → لون الخطوط والأرقام (RGBA)، مثل أخضر/سماوي أو أحمر.
-      label_every      → كل كم بكسل حقيقي تُكتب فيه تسمية إحداثي (x,y) كاملة عند التقاطعات.
-      major_only_labels → إذا True، الأرقام على الحواف تظهر فقط عند خطوط "رئيسية" (مضاعفات label_every).
+      line_color       → لون الخطوط والأرقام (RGBA).
+      label_every      → كل كم بكسل تُكتب فيه تسمية إحداثي (x,y) كاملة عند التقاطعات.
+      major_only_labels → إذا True، الأرقام على الحواف تظهر فقط عند خطوط "رئيسية".
     """
-    from PIL import Image, ImageDraw
+    from PIL import ImageDraw
     img = base_img.copy()
     draw = ImageDraw.Draw(img, "RGBA")
 
@@ -679,7 +646,6 @@ def _render_grid_variant(base_img, ow, oh, sw, sh, mx, my, display,
             y_majors.append((y_sc, y_r))
         y_sc += step_y; y_r += grid_step
 
-    # تسمية إحداثي (x,y) كاملة عند كل تقاطع "رئيسي" — تضمن رقماً حقيقياً قريباً من كل منطقة
     for (xs, xr) in x_majors:
         for (ys, yr) in y_majors:
             label = f"{xr},{yr}"
@@ -700,26 +666,25 @@ def _render_grid_variant(base_img, ow, oh, sw, sh, mx, my, display,
     return final
 
 
-def capture_with_grid(display: str, scale: float = 0.65, quality: int = 72,
+def capture_with_grid(display: str, scale: float = 0.85, quality: int = 72,
                       force_mx: int | None = None,
                       force_my: int | None = None,
                       grid_step: int = 50) -> dict:
     """
-    يلتقط الشاشة من display محدد ويُنتج 4 نسخ من نفس اللقطة بالضبط (نفس اللحظة):
-      - "data"        → النسخة العادية (نظيفة تماماً) + علامة الماوس فقط، بدون أي Grid.
-                         هذه فقط تُعرض للمستخدم في الواجهة كـ "الشاشة الحقيقية".
-      - "data_grid"   → شبكة إحداثيات عادية (كل 50px)، أخضر/سماوي — للذكاء الاصطناعي.
-      - "data_grid2"  → شبكة إحداثيات أدق (كل 25px)، نفس الألوان — للذكاء الاصطناعي.
-      - "data_grid3"  → شبكة إحداثيات فائقة الدقة (كل 10px تقريباً)، باللون الأحمر — للذكاء الاصطناعي.
-    الثلاث نسخ الأخيرة كلها من نفس اللقطة الأصلية بالضبط (نفس اللحظة، لا التقاط متكرر)
-    لضمان تطابقها تماماً ولتفادي أي تأخير أو اختلاف بينها.
+    يلتقط الشاشة من display محدد ويُنتج 3 نسخ من نفس اللقطة بالضبط (نفس اللحظة):
+      - "data"       → النسخة العادية (نظيفة تماماً) + علامة الماوس فقط، بدون أي Grid.
+      - "data_grid"  → شبكة إحداثيات عادية (كل 50px)، أخضر/سماوي — للذكاء الاصطناعي.
+      - "data_grid2" → شبكة إحداثيات أدق (كل 20px)، أحمر — للنقرات الدقيقة.
+    —— تبسيط v13: نسختان فقط (بدل 3) لتقليل عدد عمليات resize/encode لكل
+    لقطة بنسبة قرابة س4إلى س2، ودقة المقاس الواحد 1280x800 الجديدة لم
+    تعد تحتاج لثلاث تدرجات دقة منفصلة لتحديد الإحداثيات.
     """
     from PIL import Image, ImageDraw
 
     img, ow, oh = _capture_raw(display)
     if img is None:
         return {"data": "", "data_grid": "", "data_grid2": "", "data_grid3": "",
-                "width": 1920, "height": 1080, "mouse_x": 0, "mouse_y": 0}
+                "width": 1280, "height": 800, "mouse_x": 0, "mouse_y": 0}
 
     mx, my = (force_mx, force_my) if force_mx is not None else _get_mouse_pos(display)
 
@@ -729,7 +694,6 @@ def capture_with_grid(display: str, scale: float = 0.65, quality: int = 72,
     msx = int(mx * sw / ow)
     msy = int(my * sh / oh)
 
-    # ── النسخة العادية النظيفة (بدون أي شبكة) — فقط علامة الماوس ─────────
     clean_img = base_img.copy()
     draw_clean = ImageDraw.Draw(clean_img, "RGBA")
     _draw_mouse_marker(draw_clean, msx, msy)
@@ -738,32 +702,23 @@ def capture_with_grid(display: str, scale: float = 0.65, quality: int = 72,
     clean_final.save(buf_clean, format="JPEG", quality=quality, optimize=True)
     data_clean = base64.b64encode(buf_clean.getvalue()).decode()
 
-    # ── نسخة شبكة عادية: كل 50px، أخضر/سماوي ────────────────────────────
     grid1 = _render_grid_variant(base_img, ow, oh, sw, sh, mx, my, display,
                                   grid_step=grid_step, line_color=(0, 255, 180, 235),
                                   label_every=100)
     buf1 = io.BytesIO(); grid1.save(buf1, format="JPEG", quality=quality, optimize=True)
     data_grid1 = base64.b64encode(buf1.getvalue()).decode()
 
-    # ── نسخة شبكة أدق: كل 25px، نفس الألوان ──────────────────────────────
     grid2 = _render_grid_variant(base_img, ow, oh, sw, sh, mx, my, display,
-                                  grid_step=25, line_color=(0, 255, 180, 235),
-                                  label_every=100)
-    buf2 = io.BytesIO(); grid2.save(buf2, format="JPEG", quality=quality, optimize=True)
+                                  grid_step=20, line_color=(255, 60, 60, 235),
+                                  label_every=60, major_only_labels=True)
+    buf2 = io.BytesIO(); grid2.save(buf2, format="JPEG", quality=max(quality, 78), optimize=True)
     data_grid2 = base64.b64encode(buf2.getvalue()).decode()
 
-    # ── نسخة شبكة فائقة الدقة: كل 10px تقريباً، أحمر بالكامل ────────────
-    grid3 = _render_grid_variant(base_img, ow, oh, sw, sh, mx, my, display,
-                                  grid_step=10, line_color=(255, 60, 60, 235),
-                                  label_every=50, major_only_labels=True)
-    buf3 = io.BytesIO(); grid3.save(buf3, format="JPEG", quality=max(quality, 78), optimize=True)
-    data_grid3 = base64.b64encode(buf3.getvalue()).decode()
-
     return {
-        "data": data_clean,         # النسخة العادية النظيفة (تُعرض للمستخدم فقط)
-        "data_grid": data_grid1,    # شبكة عادية 50px (أخضر/سماوي)
-        "data_grid2": data_grid2,   # شبكة أدق 25px (أخضر/سماوي)
-        "data_grid3": data_grid3,   # شبكة فائقة الدقة 10px (أحمر)
+        "data": data_clean,
+        "data_grid": data_grid1,
+        "data_grid2": data_grid2,
+        "data_grid3": data_grid2,  # توافقية رجعية: نفس قيمة data_grid2 لأي كود قديم يقرأ data_grid3
         "width": ow, "height": oh, "mouse_x": mx, "mouse_y": my,
     }
 
@@ -1058,75 +1013,94 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
         لأن المحتوى متوقع أن يكون مختلفاً (صفحة تحمّلت أكثر) حتى لو تشابه الـ hash
         جزئياً مع خلفية مشابهة.
         """
-        await asyncio.sleep(delay)
-        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"]))
+        try:
+            await asyncio.sleep(delay)
+            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 _safe_capture(0.65, 72, force_mx, force_my)
-        sess["last_bg_shot_ts"] = time.time()
-        if result["data"]:
-            fh = _frame_hash(result["data"])
-            if fh != sess.get("last_bg_hash", ""):
-                sess["last_bg_hash"] = fh
-                await send({
-                    "type": "screenshot",
-                    "data": result["data"],
-                    "data_grid": result.get("data_grid", ""),
-                    "data_grid2": result.get("data_grid2", ""),
-                    "data_grid3": result.get("data_grid3", ""),
-                    "ts": int(time.time() * 1000),
-                    "auto": True, "label": label,
-                    "screen_width": result["width"],
-                    "screen_height": result["height"],
-                    "mouse_x": result["mouse_x"],
-                    "mouse_y": result["mouse_y"],
-                    "has_grid": True,
-                })
-
-        if extra_shot_delay:
-            await asyncio.sleep(extra_shot_delay)
-            result2 = await _safe_capture(0.65, 72, force_mx, force_my)
+            result = await _safe_capture(0.65, 72, force_mx, force_my)
             sess["last_bg_shot_ts"] = time.time()
-            if result2["data"]:
-                fh2 = _frame_hash(result2["data"])
-                sess["last_bg_hash"] = fh2
-                await send({
-                    "type": "screenshot",
-                    "data": result2["data"],
-                    "data_grid": result2.get("data_grid", ""),
-                    "data_grid2": result2.get("data_grid2", ""),
-                    "data_grid3": result2.get("data_grid3", ""),
-                    "ts": int(time.time() * 1000),
-                    "auto": True, "label": f"{label} (delayed)",
-                    "screen_width": result2["width"],
-                    "screen_height": result2["height"],
-                    "mouse_x": result2["mouse_x"],
-                    "mouse_y": result2["mouse_y"],
-                    "has_grid": True,
-                })
+            if result["data"]:
+                fh = _frame_hash(result["data"])
+                if fh != sess.get("last_bg_hash", ""):
+                    sess["last_bg_hash"] = fh
+                    await send({
+                        "type": "screenshot",
+                        "data": result["data"],
+                        "data_grid": result.get("data_grid", ""),
+                        "data_grid2": result.get("data_grid2", ""),
+                        "data_grid3": result.get("data_grid3", ""),
+                        "ts": int(time.time() * 1000),
+                        "auto": True, "label": label,
+                        "screen_width": result["width"],
+                        "screen_height": result["height"],
+                        "mouse_x": result["mouse_x"],
+                        "mouse_y": result["mouse_y"],
+                        "has_grid": True,
+                    })
+
+            if extra_shot_delay:
+                await asyncio.sleep(extra_shot_delay)
+                result2 = await _safe_capture(0.65, 72, force_mx, force_my)
+                sess["last_bg_shot_ts"] = time.time()
+                if result2["data"]:
+                    fh2 = _frame_hash(result2["data"])
+                    sess["last_bg_hash"] = fh2
+                    await send({
+                        "type": "screenshot",
+                        "data": result2["data"],
+                        "data_grid": result2.get("data_grid", ""),
+                        "data_grid2": result2.get("data_grid2", ""),
+                        "data_grid3": result2.get("data_grid3", ""),
+                        "ts": int(time.time() * 1000),
+                        "auto": True, "label": f"{label} (delayed)",
+                        "screen_width": result2["width"],
+                        "screen_height": result2["height"],
+                        "mouse_x": result2["mouse_x"],
+                        "mouse_y": result2["mouse_y"],
+                        "has_grid": True,
+                    })
+        except Exception as e:
+            # لقطة خلفية فاشلة لا يجب أن توقف الجلسة أو تظهر بصمت في اللوق فقط.
+            print(f"[shot_bg:{display}] ⚠️ {e}")
 
     async def shot_explicit(label: str = ""):
         """screenshot صريح — يُرسل دائماً بدون delta suppression، وله أولوية مطلقة
-        على أي عملية shot_bg تلقائية جارية (لا ينتظر خلفها طويلاً)."""
-        result = await _priority_capture(0.65, 75)
-        if not result["data"]:
-            return
-        sess["last_bg_hash"] = _frame_hash(result["data"])
-        await send({
-            "type": "screenshot",
-            "data": result["data"],
-            "data_grid": result.get("data_grid", ""),
-            "data_grid2": result.get("data_grid2", ""),
-            "data_grid3": result.get("data_grid3", ""),
-            "ts": int(time.time() * 1000),
-            "auto": False, "label": label,
-            "screen_width": result["width"],
-            "screen_height": result["height"],
-            "mouse_x": result["mouse_x"],
-            "mouse_y": result["mouse_y"],
-            "has_grid": True,
-        })
+        على أي عملية shot_bg تلقائية جارية (لا ينتظر خلفها طويلاً).
+        ── إصلاح جذري: try/except شامل + إرسال رسالة خطأ صريحة للعميل ──
+        المشكلة القديمة: هذه الدالة تُشغَّل عبر asyncio.create_task بدون أي
+        معالجة استثناء محيطة بها. أي خطأ غير متوقع كان يُسقط الـ task بالكامل
+        بصمت تام — لا رسالة تصل للعميل ولا حتى سطر في اللوق، فيبقى العميل
+        ينتظر frame لن يصل أبداً. الآن أي فشل يُسجَّل ويُرسَل كرسالة "error"
+        صريحة، والعميل (index.html) يتعامل معها ويعيد المحاولة فوراً."""
+        try:
+            result = await _priority_capture(0.65, 75)
+            if not result or not result["data"]:
+                print(f"[shot_explicit:{display}] ⚠️ empty capture result")
+                await send({"type": "error", "action": "screenshot", "msg": "capture returned empty"})
+                return
+            sess["last_bg_hash"] = _frame_hash(result["data"])
+            await send({
+                "type": "screenshot",
+                "data": result["data"],
+                "data_grid": result.get("data_grid", ""),
+                "data_grid2": result.get("data_grid2", ""),
+                "data_grid3": result.get("data_grid3", ""),
+                "ts": int(time.time() * 1000),
+                "auto": False, "label": label,
+                "screen_width": result["width"],
+                "screen_height": result["height"],
+                "mouse_x": result["mouse_x"],
+                "mouse_y": result["mouse_y"],
+                "has_grid": True,
+            })
+        except Exception as e:
+            print(f"[shot_explicit:{display}] ❌ EXCEPTION: {e}")
+            try:
+                await send({"type": "error", "action": "screenshot", "msg": str(e)})
+            except Exception:
+                pass
 
     # ── reset_computer: إعادة ضبط الكمبيوتر كأنه جديد ─────────
     if action == "reset_computer":
@@ -1145,7 +1119,17 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
     # هذا يضمن أن أي إجراء لاحق (نقرة، طباعة، طلب screenshot آخر) يصل ويُعالَج
     # فوراً دون انتظار اكتمال هذه اللقطة أولاً.
     if action == "screenshot":
-        asyncio.create_task(shot_explicit("explicit screenshot"))
+        # ── طبقة حماية إضافية: حتى لو حصل خطأ غير متوقع تماماً داخل
+        # shot_explicit تفلت من الـ try/except الداخلي (مثل CancelledError
+        # أو خطأ عند إنشاء الـ task نفسه)، هذا الغلاف الخارجي يضمن تسجيله
+        # في اللوق بدل أن يختفي بصمت كـ "unhandled task exception" في event
+        # loop بايثون (وهذا كان له سلوك افتراضي بصامت في بعض إعدادات uvicorn).
+        _task = asyncio.create_task(shot_explicit("explicit screenshot"))
+        def _on_shot_done(t: asyncio.Task):
+            exc = t.exception() if not t.cancelled() else None
+            if exc:
+                print(f"[screenshot-task:{display}] ❌ unhandled exception: {exc}")
+        _task.add_done_callback(_on_shot_done)
 
     # ── terminal ─────────────────────────────────────────────
     elif action == "terminal":
@@ -1281,8 +1265,9 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
             _wipe_firefox_session_data(profile_dir)
             # حقن --profile داخل أمر فايرفوكس (إن لم يكن محقوناً مسبقاً)
             if "--profile" not in cmd and "-P " not in cmd:
-                cmd = cmd.replace("firefox", f"firefox --profile '{profile_dir}' --no-remote", 1)
-        env = {**os.environ, "DISPLAY": display}
+                flags_str = " ".join(FIREFOX_CLI_FLAGS)
+                cmd = cmd.replace("firefox", f"firefox --profile '{profile_dir}' {flags_str}", 1)
+        env = {**os.environ, "DISPLAY": display, **(FIREFOX_ENV_EXTRA if "firefox" in cmd.lower() else {})}
         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")):
@@ -1305,9 +1290,9 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
             display, timeout=8
         )
         _wipe_firefox_session_data(profile_dir)
-        env = {**os.environ, "DISPLAY": display}
+        env = {**os.environ, "DISPLAY": display, **FIREFOX_ENV_EXTRA}
         proc = subprocess.Popen(
-            [BROWSER, "--profile", profile_dir, "--no-remote", url], env=env,
+            [BROWSER, "--profile", profile_dir, *FIREFOX_CLI_FLAGS, url], env=env,
             stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
         )
         with _display_lock:
@@ -1507,7 +1492,7 @@ async def health():
         ]
     return {
         "status": "ok",
-        "version": "v11-per-user-isolation",
+        "version": "v13-fast-capture-fixed-firefox",
         "browser": BROWSER,
         "active_users": n,
         "users": users,
@@ -1519,7 +1504,11 @@ async def health():
 # ════════════════════════════════════════════════════════════════
 
 async def _cleanup_tmp():
-    """ينظّف /tmp كل 5 دقائق."""
+    """ينظّف /tmp كل 5 دقائق. ملاحظة v13: محرك الالتقاط
+    الجديد (import-pipe/xlib-direct) لا يكتب أي ملفات zss_* على الإطلاق (كلشيء
+    في الذاكرة عبر pipe)، فهذه الدالة أصبحت غير ضرورية فعلياً للقطات
+    الشاشة، لكنها تُرك كشبكة أمان إضافية (مثلاً لو أضيف كود مستقبلاً
+    يكتب ملفات مؤقتة بنفس البادئة)."""
     while True:
         await asyncio.sleep(300)
         try: