Update app.py

app.py

@@ -1,24 +1,23 @@
 """
-THE Z AI — Computer Mode Server v12.1 — CDP DOM STATE + PER-USER ISOLATION
+THE Z AI — Computer Mode Server v13 — CDP DOM ELEMENTS + STALENESS GUARD + COMBINED STATE
 =====================================================================================
-v12 يضيف فوق v11 طبقة رؤية ذكية مستوحاة من Manus:
-
-  ✅ كل ما هو في v11 (عزل per-user، Xvfb، Firefox، screenshot engine)
-
-  🆕 CDP (Chrome DevTools Protocol) عبر Chromium:
-     - browser_get_elements → ترجع قائمة عناصر DOM مرقمة بإحداثياتها الدقيقة
-       (أزرار، روابط، حقول إدخال، عناصر قابلة للنقر) — بدون أي نموذج AI
-     - browser_click_element → نقر بـ index مباشرة
-     - browser_type_into_element → كتابة مباشرة داخل input/textarea
-     - browser_find_element → بحث نصي عن عنصر مناسب
-     - browser_get_state → screenshot + DOM + text في رد واحد
-     - browser_get_page_text → نص الصفحة الكامل بدون HTML
-     - browser_execute_js → تنفيذ JavaScript في المتصفح مباشرة
-     - browser_scroll_to_element → تمرير الصفحة لعنصر بالـ index
-
-  🆕 الفرق الجوهري عن v11:
-     - v11: LLM يخمّن إحداثيات x/y من شبكة مرسومة على الصورة
-     - v12: الإحداثيات مأخوذة مباشرة من DOM (دقة 100%)، LLM يختار العنصر بـ index
+v13 يضيف فوق v12 تحسينات مبنية على نفس فلسفة CDP الموجودة (بدون OmniParser —
+CDP يعطي إحداثيات حقيقية 100% من DOM مباشرة، وهو أدق وأخف من نموذج رؤية إضافي).
+هذه التحسينات مستوحاة من فلسفة agent loop عند Manus (خطوة واحدة، ملاحظة شاملة،
+قرار) وليست نسخة من بنيته التحتية السحابية (microVMs/E2B) التي تتطلب بنية
+سحابية على مستوى شركة ولا يمكن تكرارها بمجرد تعديل كود.
+
+  ✅ كل ما هو في v12 (CDP، browser_get_elements، browser_click_element، إلخ)
+
+  🆕 v13 — إجراءات جديدة:
+     - browser_type_into_element → يكتب مباشرة في حقل بـ index (click+type
+       في نداء واحد، مثل Manus browser_input(index, text))
+     - browser_find_element → بحث نصي عن عنصر بالوصف بدل تخمين id يدوياً
+     - browser_get_state → نداء واحد يجمع (عناصر + نص الصفحة + screenshot)
+       بدل 3 نداءات منفصلة — يقلل عدد الجولات قبل كل قرار فعلي
+     - staleness guard: click/type تتحقق أن الصفحة لم تتغيّر منذ آخر
+       browser_get_elements قبل استخدام الإحداثيات المخزّنة (يمنع نقر/كتابة
+       بإحداثيات قديمة بعد أي navigation لم يُبلَّغ عنه صراحة)
 
   📋 كيف يشتغل CDP هنا:
      - Chromium يُشغَّل مع --remote-debugging-port=XXXX (منفذ خاص لكل مستخدم)
@@ -26,7 +25,7 @@ v12 يضيف فوق v11 طبقة رؤية ذكية مستوحاة من Manus:
      - نقرا DOM.getDocument + DOM.querySelectorAll لكل العناصر القابلة للنقر
      - نرجع قائمة JSON منظمة: [{id, tag, text, x, y, w, h, href, type}, ...]
 
-  🔄 التوافق الخلفي: كل أدوات v11 (mouse_click, keyboard_type, إلخ) تعمل بدون تغيير
+  🔄 التوافق الخلفي: كل أدوات v11/v12 (mouse_click, keyboard_type, إلخ) تعمل بدون تغيير
 """
 
 import asyncio
@@ -457,98 +456,40 @@ async def cdp_click_element(display: str, element_id: int, elements: list) -> di
                 x, y = new_el["x"], new_el["y"]
 
     # النقر بالإحداثيات الحقيقية عبر xdotool (نفس محرك v11)
-    return {"ok": True, "x": x, "y": y, "page_x": el.get("page_x", x), "page_y": el.get("page_y", y), "tag": el.get("tag"), "text": el.get("text", "")[:50]}
+    return {"ok": True, "x": x, "y": y, "tag": el.get("tag"), "text": el.get("text", "")[:50]}
 
 
-async def cdp_find_elements(display: str, query: str, limit: int = 8) -> dict:
-    """يبحث في العناصر القابلة للتفاعل عن نص/وسم/محتوى مطابق. مفيد للـ browser_find_element."""
-    state = await cdp_get_elements(display)
-    elements = state.get("elements", [])
-    q = (query or "").strip().lower()
-    if not q:
-        return {"error": "Empty query", "matches": [], **{k: state.get(k) for k in ("page_title", "page_url", "viewport_w", "viewport_h", "scroll_y", "total_height")}}
-
-    scored = []
-    for el in elements:
-        hay = " ".join([
-            str(el.get("text", "")),
-            str(el.get("tag", "")),
-            str(el.get("role", "")),
-            str(el.get("href", "")),
-            str(el.get("type", "")),
-            str(el.get("label", "")),
-        ]).lower()
-        if q not in hay:
-            continue
-        score = 0
-        text = str(el.get("text", "")).lower()
-        role = str(el.get("role", "")).lower()
-        tag = str(el.get("tag", "")).lower()
-        href = str(el.get("href", "")).lower()
-        if q == text: score += 50
-        if q in text: score += 30
-        if q in role: score += 12
-        if q in tag: score += 8
-        if q in href: score += 10
-        if el.get("in_viewport", True): score += 6
-        # shorter labels are often better click targets
-        score += max(0, 12 - min(len(text), 12))
-        scored.append((score, el))
-
-    scored.sort(key=lambda x: (-x[0], x[1].get("id", 10**9)))
-    matches = [el for _, el in scored[:max(1, min(int(limit or 8), 25))]]
-    return {
-        "matches": matches,
-        "count": len(matches),
-        "query": query,
-        **{k: state.get(k) for k in ("page_title", "page_url", "viewport_w", "viewport_h", "scroll_y", "total_height")},
-    }
-
-
-async def cdp_type_into_element(display: str, element_id: int, text: str, elements: list) -> dict:
-    """يُفعّل عنصر إدخال ثم يكتب فيه. يعتمد على آخر DOM snapshot."""
+async def cdp_type_into_element(display: str, element_id: int, elements: list, text: str,
+                                 clear_first: bool = True) -> dict:
+    """
+    يكتب نصاً مباشرة داخل عنصر إدخال بـ index — مثل Manus browser_input(index, text).
+    يدمج خطوتين كانتا منفصلتين (click ثم keyboard_type) في نداء واحد، ويتحقق
+    أن العنصر فعلاً حقل إدخال قابل للكتابة قبل المحاولة (بدل الكتابة العمياء
+    في أي عنصر، وهو خطأ شائع عند تحويل click+type لخطوة واحدة).
+    يُعيد {"ok": True, "x": ..., "y": ...} أو {"error": "..."}.
+    """
     el = next((e for e in elements if e.get("id") == element_id), None)
     if not el:
         return {"error": f"Element {element_id} not found in elements list"}
 
-    sess = await _get_cdp_session(display)
-    if not sess:
-        return {"error": "CDP not available"}
+    tag = (el.get("tag") or "").lower()
+    role = (el.get("role") or "").lower()
+    editable_tags = {"input", "textarea"}
+    editable_roles = {"textbox", "searchbox", "combobox"}
+    if tag not in editable_tags and role not in editable_roles:
+        return {
+            "error": f"Element {element_id} is a {tag or role}, not a text input. "
+                     f"Use browser_click_element if you meant to click it."
+        }
 
-    # إذا كان العنصر خارج الشاشة، قرّبه للـ viewport أولاً.
+    x, y = el["x"], el["y"]
     if not el.get("in_viewport", True):
-        page_y = int(el.get("page_y") or el.get("y") or 0)
-        scroll_expr = f"window.scrollTo({{top: Math.max(0, {max(page_y - 350, 0)}), behavior: 'instant'}}); true;"
-        await sess.send("Runtime.evaluate", {
-            "expression": scroll_expr,
-            "returnByValue": True,
-            "awaitPromise": True,
-            "timeout": 5000,
-        }, timeout=6.0)
-        await asyncio.sleep(0.25)
-        refreshed = await cdp_get_elements(display)
-        new_el = next((e for e in refreshed.get("elements", []) if e.get("id") == element_id), None)
+        new_data = await cdp_get_elements(display)
+        new_el = next((e for e in new_data.get("elements", []) if e.get("id") == element_id), None)
         if new_el:
-            el = new_el
-
-    x, y = int(el.get("x", 0)), int(el.get("y", 0))
-    tag = str(el.get("tag", "")).lower()
-    el_type = str(el.get("type", "")).lower()
-    is_text_input = tag in {"input", "textarea"} or el.get("role") == "textbox" or el.get("contenteditable")
+            x, y = new_el["x"], new_el["y"]
 
-    # نضمن أن التركيز على العنصر الصحيح ثم نكتب.
-    await asyncio.sleep(0.05)
-    return {
-        "ok": True,
-        "x": x,
-        "y": y,
-        "page_x": el.get("page_x", x),
-        "page_y": el.get("page_y", y),
-        "tag": tag,
-        "type": el_type,
-        "is_text_input": bool(is_text_input),
-        "text": str(text),
-    }
+    return {"ok": True, "x": x, "y": y, "tag": tag or role, "clear_first": clear_first}
 
 
 async def cdp_get_page_text(display: str) -> dict:
@@ -601,6 +542,48 @@ async def cdp_execute_js(display: str, js_code: str) -> dict:
     return {"result": r.get("value"), "type": r.get("type", "undefined")}
 
 
+async def _elements_are_stale(display: str, cached_url: str) -> bool:
+    """
+    يتحقق أن الصفحة الحالية ما زالت نفسها اللي التُقطت منها last_elements.
+    إحداثيات عنصر مأخوذة من صفحة قديمة قد تشير الآن لعنصر مختلف تماماً
+    (أو فراغ) بعد أي navigation — هذا فحص رخيص (URL فقط) يمنع نقرات/كتابة
+    عمياء في عنصر خاطئ بعد تنقّل لم يُبلَّغ عنه صراحة.
+    """
+    if not cached_url:
+        return False  # لا معلومة سابقة كافية — لا نمنع، فقط لا نتحقق
+    current = await cdp_get_page_text(display)
+    current_url = current.get("url", "")
+    if not current_url:
+        return False  # فشل الفحص نفسه — لا نمنع تنفيذ الأمر بسببه
+    return current_url != cached_url
+
+
+def cdp_find_elements_by_text(elements: list, query: str, limit: int = 8) -> list:
+    """
+    يبحث عن عناصر بمطابقة نصية جزئية (case-insensitive) في النص/الوصف/href.
+    يسمح للـ LLM بقول "دوس على زر تسجيل الدخول" بدل قراءة القائمة الكاملة
+    وتخمين رقم id — أقرب لطريقة تفكير Manus عن الواجهة (بالوصف الوظيفي
+    مش بمسح يدوي لكل عنصر).
+    """
+    if not query or not elements:
+        return []
+    q = query.strip().lower()
+    scored = []
+    for el in elements:
+        haystack = " ".join([
+            str(el.get("text", "")),
+            str(el.get("href", "")),
+            str(el.get("role", "")),
+            str(el.get("type", "")),
+        ]).lower()
+        if q in haystack:
+            # تفضيل التطابق الأدق (بداية النص) على التطابق الجزئي فقط
+            score = 0 if str(el.get("text", "")).lower().startswith(q) else 1
+            scored.append((score, el))
+    scored.sort(key=lambda t: t[0])
+    return [e for _, e in scored[:limit]]
+
+
 async def cdp_navigate(display: str, url: str) -> dict:
     """يُنقل المتصفح لرابط معين عبر CDP — أسرع وأكثر موثوقية من xdotool."""
     sess = await _get_cdp_session(display)
@@ -964,8 +947,6 @@ async def get_or_create_user_session(user_id: str, ws: WebSocket) -> dict:
             "created": time.time(),
             "consecutive_capture_failures": 0,  # عدّاد فشل الالتقاط المتتالي — يُصفَّر عند أي نجاح أو reset
             "cdp_port": _get_cdp_port(display),  # v12: منفذ CDP الخاص بهذا المستخدم
-            "last_page_url": "",  # v12: آخر URL تم جمع العناصر منه
-            "last_page_title": "",
             "last_elements": [],  # v12: آخر قائمة عناصر DOM (للـ click_element)
         }
         _user_displays[user_id] = sess
@@ -1560,7 +1541,7 @@ async def run_cmd_smart(cmd: str, display: str, timeout: int = 60) -> dict:
 # ── FastAPI App ───────────────────────────────────────────────
 # ════════════════════════════════════════════════════════════════
 
-app = FastAPI(title="Z-Computer-Mode v12.1 — CDP DOM State + Per-User Isolation")
+app = FastAPI(title="Z-Computer-Mode v11 — Per-User Isolation")
 app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True,
                    allow_methods=["*"], allow_headers=["*"])
 
@@ -1631,8 +1612,8 @@ def _format_elements_for_llm(elements: list) -> str:
             lines.append(_format_single_element(el))
 
     lines.append(f"\n💡 To click element N: use action='browser_click_element' with id=N")
-    lines.append("💡 To type into an input: use action='browser_type_into_element' with id=N")
-    lines.append("💡 To search elements by text: use action='browser_find_element' with query=...")
+    lines.append(f"💡 To type into an input N: use action='browser_type_into_element' with id=N, text='...'")
+    lines.append(f"💡 To find an element by description: use action='browser_find_element' with query='...'")
     return "\n".join(lines)
 
 
@@ -2234,12 +2215,12 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
         result = await cdp_get_elements(display)
         elements = result.get("elements", [])
 
-        # خزّن قائمة العناصر في الـ session للاستخدام في click_element
+        # خزّن قائمة العناصر + رابط الصفحة وقت الالتقاط، للاستخدام في
+        # click/type/scroll لاحقاً مع التحقق من عدم تغيّر الصفحة (staleness guard)
         with _display_lock:
             if sess["user_id"] in _user_displays:
                 _user_displays[sess["user_id"]]["last_elements"] = elements
-                _user_displays[sess["user_id"]]["last_page_url"] = result.get("page_url", "")
-                _user_displays[sess["user_id"]]["last_page_title"] = result.get("page_title", "")
+                _user_displays[sess["user_id"]]["last_elements_url"] = result.get("page_url", "")
 
         await send({
             "type": "browser_elements",
@@ -2263,9 +2244,9 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
         element_id = int(data.get("id", -1))
 
         with _display_lock:
-            state = _user_displays.get(sess["user_id"], {})
-            elements = state.get("last_elements", [])
-            last_url = state.get("last_page_url", "")
+            user_disp = _user_displays.get(sess["user_id"], {})
+            elements = user_disp.get("last_elements", [])
+            cached_url = user_disp.get("last_elements_url", "")
 
         if element_id < 0 or not elements:
             await send({
@@ -2274,10 +2255,12 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
             })
             return
 
-        current = await cdp_get_elements(display)
-        current_url = current.get("page_url", "")
-        if last_url and current_url and last_url != current_url:
-            await send({"type": "error", "msg": "Cached DOM is stale. Call browser_get_elements again on the current page."})
+        if await _elements_are_stale(display, cached_url):
+            await send({
+                "type": "error",
+                "msg": "Page changed since last browser_get_elements — element coordinates are stale. Call browser_get_elements again before clicking.",
+                "stale": True,
+            })
             return
 
         click_info = await cdp_click_element(display, element_id, elements)
@@ -2302,403 +2285,53 @@ async def handle_action(ws: WebSocket, msg: dict, sess: dict):
         asyncio.create_task(shot_bg("after element click", delay=0.8, extra_shot_delay=2.0))
 
     # ── browser_type_into_element ────────────────────────────
-    # كتابة مباشرة في input/textarea بواسطة id — أقرب لسلوك Manus browser_input
+    # يكتب مباشرة في حقل بـ index — يدمج click + keyboard_type في نداء
+    # واحد (مثل Manus browser_input(index, text)) بدل خطوتين منفصلتين
     elif action == "browser_type_into_element":
         element_id = int(data.get("id", -1))
-        text_value = str(data.get("text", ""))
+        text = data.get("text", "")
+        clear_first = data.get("clear_first", True)
+
         with _display_lock:
-            sess_state = _user_displays.get(sess["user_id"], {})
-            elements = sess_state.get("last_elements", [])
-            last_url = sess_state.get("last_page_url", "")
+            user_disp = _user_displays.get(sess["user_id"], {})
+            elements = user_disp.get("last_elements", [])
+            cached_url = user_disp.get("last_elements_url", "")
+
         if element_id < 0 or not elements:
-            await send({"type": "error", "msg": "Call browser_get_elements first, then use the returned element id"})
+            await send({
+                "type": "error",
+                "msg": "Call browser_get_elements first, then use the returned element id",
+            })
             return
-        current = await cdp_get_elements(display)
-        current_url = current.get("page_url", "")
-        if last_url and current_url and last_url != current_url:
-            await send({"type": "error", "msg": "Cached DOM is stale. Call browser_get_elements again on the current page."})
+
+        if await _elements_are_stale(display, cached_url):
+            await send({
+                "type": "error",
+                "msg": "Page changed since last browser_get_elements — element coordinates are stale. Call browser_get_elements again before typing.",
+                "stale": True,
+            })
             return
-        type_info = await cdp_type_into_element(display, element_id, text_value, elements)
+
+        type_info = await cdp_type_into_element(display, element_id, elements, text, clear_first)
         if "error" in type_info:
             await send({"type": "error", "msg": type_info["error"]})
             return
-        await xdo(["mousemove", "--sync", str(type_info["x"]), str(type_info["y"])], display)
-        await asyncio.sleep(0.05)
+
+        x, y = type_info["x"], type_info["y"]
+        await xdo(["mousemove", "--sync", str(x), str(y)], display)
+        await asyncio.sleep(0.07)
         await xdo(["click", "1"], display)
-        await asyncio.sleep(0.08)
-        await type_smart(text_value, display)
+        await asyncio.sleep(0.05)
+        if clear_first:
+            await xdo(["key", "--clearmodifiers", "ctrl+a"], display)
+            await xdo(["key", "--clearmodifiers", "Delete"], display)
+        await type_smart(text, display)
+
         await send({
             "type": "ack",
             "action": "browser_type_into_element",
             "element_id": element_id,
-            "tag": type_info.get("tag", ""),
-            "x": type_info["x"], "y": type_info["y"],
-            "text_len": len(text_value),
-        })
-        asyncio.create_task(shot_bg("after element type", delay=0.8, extra_shot_delay=2.0))
-
-    # ── browser_find_element ─────────────────────────────────
-    elif action == "browser_find_element":
-        query = str(data.get("query", "")).strip()
-        limit = int(data.get("limit", 8) or 8)
-        if not query:
-            await send({"type": "error", "msg": "No query provided"})
-            return
-        found = await cdp_find_elements(display, query, limit=limit)
-        matches = found.get("matches", [])
-        with _display_lock:
-            if sess["user_id"] in _user_displays:
-                _user_displays[sess["user_id"]]["last_elements"] = found.get("matches", [])
-                _user_displays[sess["user_id"]]["last_page_url"] = found.get("page_url", "")
-                _user_displays[sess["user_id"]]["last_page_title"] = found.get("page_title", "")
-        await send({
-            "type": "browser_find_result",
-            "query": query,
-            "count": len(matches),
-            "matches": matches,
-            "summary": _format_elements_for_llm(matches),
-            "page_title": found.get("page_title", ""),
-            "page_url": found.get("page_url", ""),
-            "error": found.get("error"),
-        })
-
-    # ── browser_get_page_text ────────────────────────────────
-    # نص الصفحة الكامل — مثل Manus shell_view لكن للمتصفح
-    elif action == "browser_get_page_text":
-        result = await cdp_get_page_text(display)
-        await send({
-            "type": "browser_page_text",
-            "text": result.get("text", ""),
-            "title": result.get("title", ""),
-            "url": result.get("url", ""),
-            "char_count": result.get("char_count", 0),
-            "error": result.get("error"),
-        })
-
-    # ── browser_get_state ─────────────────────────────────────
-    # لقطة واحدة تجمع screenshot + DOM state + النص + العناصر
-    elif action == "browser_get_state":
-        scale = float(data.get("scale", 0.65) or 0.65)
-        quality = int(data.get("quality", 72) or 72)
-        result = await asyncio.to_thread(capture_with_grid, display, scale, quality)
-        dom = await cdp_get_elements(display)
-        txt = await cdp_get_page_text(display)
-        elements = dom.get("elements", [])
-        with _display_lock:
-            if sess["user_id"] in _user_displays:
-                _user_displays[sess["user_id"]]["last_elements"] = elements
-                _user_displays[sess["user_id"]]["last_page_url"] = dom.get("page_url", "")
-                _user_displays[sess["user_id"]]["last_page_title"] = dom.get("page_title", "")
-        await send({
-            "type": "browser_state",
-            "image": result["data"],
-            "image_grid": result.get("data_grid", ""),
-            "image_grid2": result.get("data_grid2", ""),
-            "screen_width": result["width"],
-            "screen_height": result["height"],
-            "mouse_x": result["mouse_x"],
-            "mouse_y": result["mouse_y"],
-            "elements": elements,
-            "count": len(elements),
-            "summary": _format_elements_for_llm(elements),
-            "page_title": dom.get("page_title", txt.get("title", "")),
-            "page_url": dom.get("page_url", txt.get("url", "")),
-            "page_text": txt.get("text", ""),
-            "char_count": txt.get("char_count", 0),
-            "error": dom.get("error") or txt.get("error"),
-        })
-
-    # ── browser_execute_js ───────────────────────────────────
-    # تنفيذ JavaScript — مثل Manus browser_console_exec
-    elif action == "browser_execute_js":
-        js_code = data.get("code", "")
-        if not js_code:
-            await send({"type": "error", "msg": "No JS code provided"})
-            return
-        result = await cdp_execute_js(display, js_code)
-        await send({
-            "type": "browser_js_result",
-            "result": result.get("result"),
-            "type_name": result.get("type", "undefined"),
-            "error": result.get("error"),
+            "x": x, "y": y,
+            "text_len": len(text),
         })
-
-    # ── browser_navigate ─────────────────────────────────────
-    # انتقال سريع لرابط عبر CDP بدون إعادة فتح المتصفح
-    elif action == "browser_navigate":
-        url = _safe_search(data.get("url", ""))
-        if not url:
-            await send({"type": "error", "msg": "No URL provided"})
-            return
-
-        if BROWSER_SUPPORTS_CDP:
-            result = await cdp_navigate(display, url)
-            if "ok" in result:
-                await send({"type": "ack", "action": "browser_navigate", "url": url, "cdp": True})
-                # انتظر تحميل الصفحة ثم التقط
-                asyncio.create_task(shot_bg("after cdp navigate", delay=1.5, extra_shot_delay=2.5))
-            else:
-                # fallback لـ xdotool إذا فشل CDP
-                await xdo(["key", "--clearmodifiers", "ctrl+l"], display)
-                await asyncio.sleep(0.2)
-                await type_smart(url, display)
-                await xdo(["key", "--clearmodifiers", "Return"], display)
-                await send({"type": "ack", "action": "browser_navigate", "url": url, "cdp": False})
-        else:
-            await xdo(["key", "--clearmodifiers", "ctrl+l"], display)
-            await asyncio.sleep(0.2)
-            await type_smart(url, display)
-            await xdo(["key", "--clearmodifiers", "Return"], display)
-            await send({"type": "ack", "action": "browser_navigate", "url": url, "cdp": False})
-        # ── تعطيل الالتقاط التلقائي — shot_bg أعلاه يتكفل بها ──
-
-    # ── browser_scroll_to_element ────────────────────────────
-    # تمرير الصفحة لعنصر معين بـ index
-    elif action == "browser_scroll_to_element":
-        element_id = int(data.get("id", -1))
-        with _display_lock:
-            state = _user_displays.get(sess["user_id"], {})
-            elements = state.get("last_elements", [])
-            last_url = state.get("last_page_url", "")
-        el = next((e for e in elements if e.get("id") == element_id), None)
-        if not el:
-            await send({"type": "error", "msg": f"Element {element_id} not found"})
-            return
-        current = await cdp_get_elements(display)
-        current_url = current.get("page_url", "")
-        if last_url and current_url and last_url != current_url:
-            await send({"type": "error", "msg": "Cached DOM is stale. Call browser_get_elements again on the current page."})
-            return
-        page_y = int(el.get("page_y") or el.get("y") or 0)
-        await cdp_execute_js(display,
-            f"window.scrollTo({{top: Math.max(0, {max(page_y - 350, 0)}), behavior:'instant'}}); true;"
-        )
-        await asyncio.sleep(0.4)
-        await send({"type": "ack", "action": "browser_scroll_to_element", "element_id": element_id})
-        asyncio.create_task(shot_bg("after scroll to element", delay=0.8))
-
-    # ── unknown ──────────────────────────────────────────────
-    else:
-        await send({"type": "error", "msg": f"Unknown action: '{action}'"})
-
-
-# ════════════════════════════════════════════════════════════════
-# ── WebSocket Endpoint ────────────────────────────────────────
-# ════════════════════════════════════════════════════════════════
-
-@app.websocket("/ws")
-async def websocket_endpoint(
-    ws: WebSocket,
-    user_id: str = Query(default="anonymous")
-):
-    await ws.accept()
-
-    # الحصول على session المستخدم أو إنشاء واحدة جديدة
-    sess = await get_or_create_user_session(user_id, ws)
-
-    # تأكد أن Xvfb يعمل لهذا المستخدم
-    await ensure_xvfb_for_session(sess)
-
-    display = sess["display"]
-
-    async def _heartbeat():
-        while True:
-            await asyncio.sleep(20)
-            try:
-                await ws.send_text(json.dumps({"type": "ping", "ts": int(time.time()*1000)}))
-            except Exception:
-                break
-
-    hb_task = asyncio.create_task(_heartbeat())
-
-    try:
-        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": display,
-            "user_id": user_id,
-            "session_id": id(ws),
-            "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, display, 0.65, 72)
-        if result["data"]:
-            await ws.send_text(json.dumps({
-                "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),
-                "label": "Initial screen",
-                "screen_width": result["width"],
-                "screen_height": result["height"],
-                "mouse_x": result["mouse_x"],
-                "mouse_y": result["mouse_y"],
-                "has_grid": True,
-            }, ensure_ascii=False))
-            sess["last_bg_hash"] = _frame_hash(result["data"])
-
-    except Exception as e:
-        print(f"[ws:{user_id}] init error: {e}")
-
-    try:
-        while True:
-            raw = await ws.receive_text()
-            try:
-                msg = json.loads(raw)
-                if msg.get("type") == "pong":
-                    continue
-                await handle_action(ws, msg, sess)
-            except json.JSONDecodeError:
-                pass
-    except WebSocketDisconnect:
-        pass
-    except Exception as e:
-        print(f"[ws:{user_id}] error: {e}")
-    finally:
-        hb_task.cancel()
-        await destroy_user_ws(user_id, ws)
-
-
-# ════════════════════════════════════════════════════════════════
-# ── REST Endpoints ────────────────────────────────────────────
-# ════════════════════════════════════════════════════════════════
-
-@app.get("/screenshot")
-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"],
-        "image_grid": result.get("data_grid", ""),
-        "image_grid2": result.get("data_grid2", ""),
-        "image_grid3": result.get("data_grid3", ""),
-        "ts": int(time.time() * 1000),
-        "screen_width": result["width"],
-        "screen_height": result["height"],
-        "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):
-    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():
-    with _display_lock:
-        n = len(_user_displays)
-        users = [
-            {
-                "user_id": uid,
-                "display": s["display"],
-                "cdp_port": s.get("cdp_port"),
-                "connected": bool(s.get("active_ws")),
-                "elements_cached": len(s.get("last_elements", [])),
-            }
-            for uid, s in _user_displays.items()
-        ]
-    with _cdp_sessions_lock:
-        cdp_active = sum(1 for s in _cdp_sessions.values() if s._ws)
-    return {
-        "status": "ok",
-        "version": "v12-cdp-dom-elements",
-        "browser": BROWSER,
-        "cdp_supported": BROWSER_SUPPORTS_CDP,
-        "cdp_library": _CDP_AVAILABLE,
-        "active_users": n,
-        "cdp_sessions_active": cdp_active,
-        "users": users,
-    }
-
-
-# ════════════════════════════════════════════════════════════════
-# ── Background Tasks ──────────────────────────────────────────
-# ════════════════════════════════════════════════════════════════
-
-async def _cleanup_tmp():
-    """ينظّف /tmp كل 5 دقائق. ملاحظة v13: محرك الالتقاط
-    الجديد (import-pipe/xlib-direct/xwd) لا يكتب أي ملفات zss_* على الإطلاق (كلشيء
-    في الذاكرة عبر pipe)، فهذه الدالة أصبحت غير ضرورية فعلياً للقطات
-    الشاشة، لكنها تُرك كشبكة أمان إضافية (مثلاً لو أضيف كود مستقبلاً
-    يكتب ملفات مؤقتة بنفس البادئة)."""
-    while True:
-        await asyncio.sleep(300)
-        try:
-            subprocess.run(
-                ["find", "/tmp", "-name", "zss_*", "-mmin", "+10", "-delete"],
-                capture_output=True, timeout=10
-            )
-        except Exception as e:
-            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():
-    asyncio.create_task(_cleanup_tmp())
-    asyncio.create_task(_cleanup_idle_sessions())
-    print("✅ Z Computer Mode v12.1 ready — CDP DOM State + Per-User Isolated Displays")
-    print(f"   Display range: :{DISPLAY_BASE} → :{DISPLAY_MAX}")
-    print(f"   Browser: {BROWSER}")
-    print(f"   CDP (Manus-style DOM): {'✅ ENABLED' if BROWSER_SUPPORTS_CDP else '⚠️ DISABLED (Firefox)'}")
-    print(f"   websockets lib: {'✅' if _CDP_AVAILABLE else '❌ (pip install websockets)'}")
-    print(f"   CDP port range: {CDP_PORT_BASE} → {CDP_PORT_BASE + (DISPLAY_MAX - DISPLAY_BASE)}")
-    print(f"   Connect: wss://your-space.hf.space/ws?user_id=EMAIL")
-    print()
-    print("   🆕 New v12 actions:")
-    print("      browser_get_elements     → DOM elements list with exact coords")
-    print("      browser_click_element    → click by index id")
-    print("      browser_type_into_element → type into input/textarea by id")
-    print("      browser_find_element      → find element by text/query")
-    print("      browser_get_state         → screenshot + DOM + text in one call")
-    print("      browser_get_page_text     → full page text content")
-    print("      browser_execute_js        → run JS in browser")
-    print("      browser_navigate          → fast CDP navigation")
-    print("      browser_scroll_to_element → scroll to element by id")
-
-
-if __name__ == "__main__":
-    port = int(os.environ.get("PORT", 7860))
-    uvicorn.run("app:app", host="0.0.0.0", port=port, log_level="info")
+        asyncio.create_task(shot_