Upload 5 files

README (42).md

@@ -0,0 +1,41 @@
+---
+title: Z Computer Mode Server
+emoji: 🖥️
+colorFrom: blue
+colorTo: purple
+sdk: docker
+pinned: false
+---
+
+# THE Z AI — Computer Mode Server
+
+سيرفر التحكم بالكمبيوتر عن بعد لمود **Computer** في تطبيق THE Z AI.
+
+## ما يفعله هذا السيرفر
+
+- يشغّل بيئة لينكس كاملة (Ubuntu 22.04 + Fluxbox Desktop)
+- يفتح WebSocket على `/ws` للتحكم الكامل
+- يدعم: لقطات شاشة، بث مباشر، أوامر ترمينال، ماوس، لوحة مفاتيح، حافظة
+
+## WebSocket Actions
+
+| الأمر | الوصف |
+|-------|--------|
+| `screenshot` | التقاط لقطة شاشة |
+| `terminal` | تنفيذ أمر bash |
+| `mouse_move` | تحريك الماوس |
+| `mouse_click` | نقر الماوس |
+| `keyboard_type` | كتابة نص |
+| `keyboard_hotkey` | اختصارات لوحة المفاتيح |
+| `scroll` | التمرير |
+| `clipboard_read/write` | قراءة/كتابة الحافظة |
+| `start_stream` | بدء البث المباشر |
+| `stop_stream` | إيقاف البث |
+| `open_app` | فتح تطبيق |
+
+## الاستخدام
+
+رابط WebSocket بعد النشر:
+```
+wss://YOUR-SPACE.hf.space/ws
+```

app (15) (8).py

@@ -0,0 +1,1111 @@
+"""
+THE Z AI — Computer Mode Server v7 — SMART CONTROL
+====================================================
+الإصلاحات الجوهرية في v7:
+  1. capture_screen_with_grid() — صورة مزدوجة: يمين نظيفة + يسار بشبكة احداثيات شفافة
+  2. أوامر بسيطة: open pc, open firefox, mouse go x y, click x y, rclick x y, type TEXT, key ENTER ...
+  3. إصلاح الكتابة العربية: xclip clipboard + xdotool key ctrl+v
+  4. إرسال احداثيات الشاشة الحقيقية + موقع الماوس مع كل screenshot
+  5. auto_shot_with_grid بعد كل خطوة
+  6. simple_command parser: يفهم أوامر بسيطة ويحولها لأفعال WebSocket
+"""
+
+import asyncio
+import base64
+import io
+import json
+import os
+import re
+import subprocess
+import time
+import urllib.parse
+
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+import uvicorn
+
+DISPLAY = os.environ.get("DISPLAY", ":1")
+os.environ["DISPLAY"] = DISPLAY
+
+# ─── تشخيص أدوات الـ capture عند البداية ─────────────
+def _check_capture_tools():
+    tools = ["scrot", "import", "xwd", "convert", "ffmpeg", "xdotool"]
+    print("─── Capture Tools Check ───")
+    for t in tools:
+        r = subprocess.run(["which", t], capture_output=True, text=True)
+        status = "✅" if r.returncode == 0 else "❌"
+        print(f"  {status} {t}: {r.stdout.strip() or 'not found'}")
+    try:
+        r2 = subprocess.run(["xdpyinfo", "-display", DISPLAY],
+                            capture_output=True, text=True, timeout=3)
+        print(f"  {'✅' if r2.returncode==0 else '❌'} DISPLAY={DISPLAY}: {'active' if r2.returncode==0 else 'not active'}")
+    except Exception as ex:
+        print(f"  ❌ DISPLAY={DISPLAY}: {ex}")
+    print("───────────────────────────")
+
+try:
+    _check_capture_tools()
+except Exception as _e:
+    print(f"[diag] {_e}")
+
+# ─── اكتشاف المتصفح ──────────────────────────────────
+def _detect_browser() -> str:
+    candidates = ["firefox", "firefox-esr", "chromium-browser", "chromium", "google-chrome"]
+    found = None
+    for c in candidates:
+        r = subprocess.run(["which", c], capture_output=True, text=True)
+        if r.returncode == 0 and r.stdout.strip():
+            found = c
+            break
+    if not found:
+        return "firefox"
+    # تأكد من وجود firefox-esr كـ symlink
+    esr_check = subprocess.run(["which", "firefox-esr"], capture_output=True, text=True)
+    if esr_check.returncode != 0:
+        real_path = subprocess.run(["which", found], capture_output=True, text=True).stdout.strip()
+        if real_path:
+            try:
+                subprocess.run(["ln", "-sf", real_path, "/usr/local/bin/firefox-esr"], check=True)
+                print(f"✅ Created firefox-esr symlink → {real_path}")
+            except Exception as e:
+                print(f"⚠️ Could not create firefox-esr symlink: {e}")
+    return found
+
+BROWSER = _detect_browser()
+print(f"🌐 Browser detected: {BROWSER}")
+
+app = FastAPI(title="Z-Computer-Mode API v7")
+app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True,
+                   allow_methods=["*"], allow_headers=["*"])
+
+active_connections: list[WebSocket] = []
+stream_active = False
+stream_fps = 3
+stream_quality = 60
+stream_scale = 0.5
+
+# ─── CURL HEADERS ────────────────────────────────────
+CURL_HEADERS = (
+    '-H "User-Agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 '
+    '(KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36" '
+    '-H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8" '
+    '-H "Accept-Language: en-US,en;q=0.9,ar;q=0.8" '
+    '-H "Accept-Encoding: gzip, deflate" '
+    '--compressed '
+    '--max-time 20 '
+    '-L '
+    '-s '
+)
+
+# ─── مصادر البحث 8+ ──────────────────────────────────
+def _build_search_sources(query: str) -> list[dict]:
+    q = urllib.parse.quote_plus(query)
+    q_raw = query.replace(' ', '+')
+    return [
+        {
+            "name": "DuckDuckGo Instant",
+            "cmd": f"curl -s --max-time 20 'https://api.duckduckgo.com/?q={q}&format=json&no_html=1&skip_disambig=1' | python3 -c \"import sys,json; d=json.load(sys.stdin); ans=d.get('AbstractText',''); rels=d.get('RelatedTopics',[]); print('ANSWER:',ans if ans else 'no direct answer'); [print('-',r.get('Text','')[:250]) for r in rels if isinstance(r,dict) and r.get('Text')]\""
+        },
+        {
+            "name": "Google News RSS",
+            "cmd": f"curl -sL {CURL_HEADERS} 'https://news.google.com/rss/search?q={q_raw}&hl=en&gl=US&ceid=US:en' | python3 -c \"import sys,re; xml=sys.stdin.read(); titles=re.findall(r'<title><!\\[CDATA\\[(.*?)\\]\\]></title>|<title>(.*?)</title>',xml); clean=lambda s:re.sub('<[^>]+>','',s); results=[(a or b).strip() for a,b in titles if (a or b).strip()][1:9]; [print(str(i+1)+'. '+t[:180]) for i,t in enumerate(results)]\""
+        },
+        {
+            "name": "Wikipedia English",
+            "cmd": f"curl -s --max-time 15 'https://en.wikipedia.org/api/rest_v1/page/summary/{q}' | python3 -c \"import sys,json; d=json.load(sys.stdin); print(d.get('title','')+'\\n'+d.get('extract','')[:1500])\" 2>/dev/null || curl -s --max-time 15 'https://en.wikipedia.org/w/api.php?action=query&list=search&srsearch={q}&format=json&srlimit=5' | python3 -c \"import sys,json,re; d=json.load(sys.stdin); [print(str(i+1)+'. '+r['title']+': '+re.sub('<[^>]+>','',r.get('snippet',''))[:200]) for i,r in enumerate(d.get('query',{{}}).get('search',[]))]\" 2>/dev/null"
+        },
+        {
+            "name": "DuckDuckGo HTML",
+            "cmd": f"curl -sL {CURL_HEADERS} 'https://html.duckduckgo.com/html/?q={q}' | python3 -c \"import sys,re; h=sys.stdin.read(); snippets=re.findall(r'class=.result__snippet[^>]*>(.*?)</a>',h,re.DOTALL); titles=re.findall(r'class=.result__title[^>]*>.*?<a[^>]*>(.*?)</a>',h,re.DOTALL); clean=lambda s:re.sub('<[^>]+>','',s).strip(); [print(str(i+1)+'. '+clean(titles[i] if i<len(titles) else '')+'\\n   '+clean(s)[:200]) for i,s in enumerate(snippets[:7])]\""
+        },
+        {
+            "name": "Bing News RSS",
+            "cmd": f"curl -sL {CURL_HEADERS} 'https://www.bing.com/news/search?q={q}&format=RSS' | python3 -c \"import sys,re; xml=sys.stdin.read(); items=re.findall(r'<item>(.*?)</item>',xml,re.DOTALL); [print(str(i+1)+'. '+re.sub('<[^>]+>','',re.search(r'<title>(.*?)</title>',it).group(1) if re.search(r'<title>',it) else '')+'\\n   '+re.sub('<[^>]+>','',re.search(r'<description>(.*?)</description>',it).group(1) if re.search(r'<description>',it) else '')[:150]) for i,it in enumerate(items[:6])]\""
+        },
+        {
+            "name": "Reddit Search",
+            "cmd": f"curl -sL {CURL_HEADERS} -H 'Accept: application/json' 'https://www.reddit.com/search.json?q={q}&sort=new&limit=8&type=link' | python3 -c \"import sys,json; d=json.load(sys.stdin); posts=d.get('data',{{}}).get('children',[]); [print(str(i+1)+'. '+p['data'].get('title','')+'\\n   r/'+p['data'].get('subreddit','')+'  Score:'+str(p['data'].get('score',''))+'\\n   '+p['data'].get('selftext','')[:200]) for i,p in enumerate(posts[:6])]\""
+        },
+        {
+            "name": "HackerNews",
+            "cmd": f"curl -s --max-time 15 'https://hn.algolia.com/api/v1/search?query={q}&hitsPerPage=8&tags=story' | python3 -c \"import sys,json; d=json.load(sys.stdin); hits=d.get('hits',[]); [print(str(i+1)+'. '+h.get('title','')+'\\n   Points:'+str(h.get('points','0'))+' | '+h.get('url','')[:80]) for i,h in enumerate(hits[:6])]\""
+        },
+        {
+            "name": "ArXiv Academic",
+            "cmd": f"curl -s --max-time 15 'https://export.arxiv.org/api/query?search_query=all:{q}&start=0&max_results=5' | python3 -c \"import sys,re; xml=sys.stdin.read(); titles=re.findall(r'<title>(.*?)</title>',xml)[1:]; summaries=re.findall(r'<summary>(.*?)</summary>',xml,re.DOTALL); [print(str(i+1)+'. '+t.strip()+'\\n   '+summaries[i].strip()[:200] if i<len(summaries) else '') for i,t in enumerate(titles[:5])]\""
+        },
+    ]
+
+
+def _extract_query_from_cmd(cmd: str) -> str:
+    patterns = [
+        r'[?&]q=([^&\'"]+)',
+        r'[?&]query=([^&\'"]+)',
+        r'[?&]search_query=all:([^&\'"]+)',
+        r"search\?q=([^&'\"\s]+)",
+    ]
+    for p in patterns:
+        m = re.search(p, cmd)
+        if m:
+            q = m.group(1).replace('+', ' ').replace('%20', ' ')
+            return urllib.parse.unquote(q)
+    return ""
+
+
+def _is_empty_result(stdout: str) -> bool:
+    if not stdout or len(stdout.strip()) < 10:
+        return True
+    empty_signals = [
+        "no direct answer", "no results", "0 results",
+        "no items", "[]", "{}", "error", "not found", "answer: no",
+    ]
+    s = stdout.strip().lower()
+    meaningful_lines = [l for l in s.split('\n') if l.strip() and not any(sig in l for sig in empty_signals)]
+    return len(meaningful_lines) < 1
+
+
+# ─── Screen Capture ─────────────────────────────────
+
+def _get_screen_size() -> tuple[int, int]:
+    """يُعيد حجم الشاشة الحقيقي"""
+    r = subprocess.run(["xdotool", "getdisplaygeometry"],
+                       env={**os.environ, "DISPLAY": DISPLAY},
+                       capture_output=True, text=True, timeout=5)
+    try:
+        parts = r.stdout.strip().split()
+        return int(parts[0]), int(parts[1])
+    except:
+        return 1920, 1080
+
+
+def _get_mouse_pos() -> tuple[int, int]:
+    """يُعيد موقع الماوس الحالي"""
+    r = subprocess.run(["xdotool", "getmouselocation"],
+                       env={**os.environ, "DISPLAY": DISPLAY},
+                       capture_output=True, text=True, timeout=5)
+    try:
+        mx = int(re.search(r"x:(\d+)", r.stdout).group(1))
+        my = int(re.search(r"y:(\d+)", r.stdout).group(1))
+        return mx, my
+    except:
+        return 0, 0
+
+
+def capture_screen_raw() -> tuple[object, int, int]:
+    """
+    يلتقط الشاشة بـ 5 طرق متسلسلة — تضمن نجاح واحدة:
+    1. scrot  (الأسرع)
+    2. import (ImageMagick)
+    3. xwd + convert
+    4. ffmpeg + x11grab
+    5. python-xlib / Xlib مباشرة
+    """
+    from PIL import Image
+    env = {**os.environ, "DISPLAY": DISPLAY}
+    tmp = f"/tmp/zs_{int(time.time()*1000)}"
+
+    def _load(path) -> tuple:
+        """تحميل الصورة إذا وُجدت وحجمها > 0"""
+        if not path or not os.path.exists(path):
+            return None, 0, 0
+        size = os.path.getsize(path)
+        if size < 512:          # صورة فارغة/تالفة
+            return None, 0, 0
+        try:
+            img = Image.open(path).convert("RGB")
+            w, h = img.size
+            if w < 10 or h < 10:
+                return None, 0, 0
+            try: os.unlink(path)
+            except: pass
+            return img, w, h
+        except Exception as ex:
+            print(f"[_load] {ex}")
+            return None, 0, 0
+
+    # ── طريقة 1: scrot ──────────────────────────────────
+    try:
+        p = tmp + "_1.png"
+        r = subprocess.run(
+            ["scrot", "-q", "95", p],
+            env=env, timeout=8, capture_output=True
+        )
+        img, w, h = _load(p)
+        if img:
+            print("[capture] ✅ scrot")
+            return img, w, h
+        print(f"[capture] scrot failed rc={r.returncode} err={r.stderr[:80]}")
+    except Exception as e:
+        print(f"[capture] scrot ex: {e}")
+
+    # ── طريقة 2: ImageMagick import ─────────────────────
+    try:
+        p = tmp + "_2.png"
+        r = subprocess.run(
+            ["import", "-window", "root", "-silent", p],
+            env=env, timeout=10, capture_output=True
+        )
+        img, w, h = _load(p)
+        if img:
+            print("[capture] ✅ import (ImageMagick)")
+            return img, w, h
+        print(f"[capture] import failed rc={r.returncode}")
+    except Exception as e:
+        print(f"[capture] import ex: {e}")
+
+    # ── طريقة 3: xwd + convert ──────────────────────────
+    try:
+        xwd_p = tmp + "_3.xwd"
+        png_p = tmp + "_3.png"
+        r1 = subprocess.run(
+            ["xwd", "-root", "-silent", "-out", xwd_p],
+            env=env, timeout=10, capture_output=True
+        )
+        r2 = subprocess.run(
+            ["convert", xwd_p, png_p],
+            timeout=10, capture_output=True
+        )
+        try: os.unlink(xwd_p)
+        except: pass
+        img, w, h = _load(png_p)
+        if img:
+            print("[capture] ✅ xwd+convert")
+            return img, w, h
+        print(f"[capture] xwd rc={r1.returncode} convert rc={r2.returncode}")
+    except Exception as e:
+        print(f"[capture] xwd ex: {e}")
+
+    # ── طريقة 4: ffmpeg x11grab ─────────────────────────
+    try:
+        p = tmp + "_4.png"
+        sw, sh = _get_screen_size()
+        r = subprocess.run([
+            "ffmpeg", "-y",
+            "-f", "x11grab",
+            "-video_size", f"{sw}x{sh}",
+            "-i", DISPLAY,
+            "-vframes", "1",
+            "-q:v", "2",
+            p
+        ], env=env, timeout=12, capture_output=True)
+        img, w, h = _load(p)
+        if img:
+            print("[capture] ✅ ffmpeg x11grab")
+            return img, w, h
+        print(f"[capture] ffmpeg rc={r.returncode} err={r.stderr[-120:]}")
+    except Exception as e:
+        print(f"[capture] ffmpeg ex: {e}")
+
+    # ── طريقة 5: python-xlib (Xlib مباشرة) ──────────────
+    try:
+        from Xlib import display as Xdisplay
+        from Xlib.ext.xtest import fake_input
+        xdisp = Xdisplay.Display(DISPLAY)
+        root = xdisp.screen().root
+        geom = root.get_geometry()
+        w, h = geom.width, geom.height
+        raw = root.get_image(0, 0, w, h,
+                             Xdisplay.X.ZPixmap,
+                             0xFFFFFFFF)
+        import struct
+        data = raw.data
+        # BGRA → RGB
+        pixels = []
+        for i in range(0, len(data), 4):
+            b, g, r_, a = struct.unpack_from('BBBB', data, i)
+            pixels.extend([r_, g, b])
+        img = Image.frombytes("RGB", (w, h), bytes(pixels))
+        print("[capture] ✅ python-xlib")
+        return img, w, h
+    except Exception as e:
+        print(f"[capture] xlib ex: {e}")
+
+    # ── طريقة 6: صورة placeholder واض��ة ────────────────
+    print("[capture] ⚠️ ALL methods failed — returning placeholder")
+    try:
+        from PIL import ImageDraw
+        sw, sh = _get_screen_size()
+        img = Image.new("RGB", (sw or 1280, sh or 720), (20, 20, 30))
+        draw = ImageDraw.Draw(img)
+        draw.rectangle([(0, 0), (sw, 40)], fill=(30, 30, 50))
+        draw.text((10, 10), f"⚠️ Screenshot failed — DISPLAY={DISPLAY}", fill=(255, 100, 100))
+        draw.text((10, 50), "Methods tried: scrot, import, xwd, ffmpeg, xlib", fill=(150, 150, 150))
+        return img, sw or 1280, sh or 720
+    except:
+        return None, 0, 0
+
+
+def capture_screen(scale=0.6, quality=70) -> str:
+    """يلتقط الشاشة العادية بدون grid"""
+    img, w, h = capture_screen_raw()
+    if img is None:
+        return ""
+    try:
+        if scale < 1.0:
+            img = img.resize((int(w * scale), int(h * scale)), img.LANCZOS)
+        buf = io.BytesIO()
+        img.save(buf, format="JPEG", quality=quality, optimize=True)
+        return base64.b64encode(buf.getvalue()).decode()
+    except Exception as e:
+        print(f"[capture] {e}")
+        return ""
+
+
+def capture_screen_with_grid(scale=0.65, quality=72,
+                              force_mx: int | None = None,
+                              force_my: int | None = None) -> dict:
+    """
+    يلتقط الشاشة ويُعيد صورة واحدة فقط مع شبكة إحداثيات واضحة.
+    الإحداثيات في الصورة تطابق إحداثيات الشاشة الحقيقية (1:1 mapping).
+    الخطوط كل 100px — الأرقام تُظهر الـ X/Y الحقيقي للنقر.
+
+    force_mx / force_my: إذا مُرِّرا يُرسم الـ cursor في هذا الموضع مباشرةً
+    بدون استعلام xdotool — يُعالج مشكلة race condition بعد mouse_move.
+    """
+    try:
+        from PIL import Image, ImageDraw
+        img, orig_w, orig_h = capture_screen_raw()
+        if img is None:
+            return {"data": "", "width": 1920, "height": 1080, "mouse_x": 0, "mouse_y": 0}
+
+        # استخدم الإحداثيات المُمرَّرة إذا وُجدت (بعد mouse_move/click مباشرة)
+        # وإلا اقرأ من X server
+        if force_mx is not None and force_my is not None:
+            mx, my = force_mx, force_my
+        else:
+            mx, my = _get_mouse_pos()
+
+        # resize للعرض فقط — الإحداثيات تبقى للشاشة الأصلية
+        sw = int(orig_w * scale)
+        sh = int(orig_h * scale)
+        grid_img = img.resize((sw, sh), Image.LANCZOS)
+        draw = ImageDraw.Draw(grid_img, "RGBA")
+
+        # شبكة كل 100px بإحداثيات الشاشة الحقيقية
+        step_orig = 100
+        step_scaled_x = int(step_orig * sw / orig_w)
+        step_scaled_y = int(step_orig * sh / orig_h)
+
+        grid_color  = (255, 255, 255, 45)   # خطوط بيضاء شفافة
+        label_color = (0, 255, 180, 200)    # أرقام خضراء واضحة
+
+        # خطوط عمودية + أرقام X الحقيقية
+        x_sc = step_scaled_x
+        x_real = step_orig
+        while x_sc < sw:
+            draw.line([(x_sc, 0), (x_sc, sh)], fill=grid_color, width=1)
+            draw.rectangle([(x_sc + 1, 2), (x_sc + 32, 14)], fill=(0, 0, 0, 160))
+            draw.text((x_sc + 2, 3), str(x_real), fill=label_color)
+            x_sc   += step_scaled_x
+            x_real += step_orig
+
+        # خطوط أفقية + أرقام Y الحقيقية
+        y_sc = step_scaled_y
+        y_real = step_orig
+        while y_sc < sh:
+            draw.line([(0, y_sc), (sw, y_sc)], fill=grid_color, width=1)
+            draw.rectangle([(2, y_sc + 1), (36, y_sc + 13)], fill=(0, 0, 0, 160))
+            draw.text((3, y_sc + 2), str(y_real), fill=label_color)
+            y_sc   += step_scaled_y
+            y_real += step_orig
+
+        # موقع الماوس الحقيقي — دائرة حمراء
+        mouse_sx = int(mx * sw / orig_w)
+        mouse_sy = int(my * sh / orig_h)
+        r = 10
+        draw.ellipse([(mouse_sx-r, mouse_sy-r), (mouse_sx+r, mouse_sy+r)],
+                     outline=(255, 60, 60, 240), width=2)
+        draw.line([(mouse_sx-16, mouse_sy), (mouse_sx+16, mouse_sy)],
+                  fill=(255, 60, 60, 200), width=1)
+        draw.line([(mouse_sx, mouse_sy-16), (mouse_sx, mouse_sy+16)],
+                  fill=(255, 60, 60, 200), width=1)
+
+        # شريط معلومات في الأعلى
+        final = grid_img.convert("RGB")
+        draw2 = ImageDraw.Draw(final)
+        draw2.rectangle([(0, 0), (sw, 18)], fill=(0, 0, 0))
+        hdr = (f"SCREEN {orig_w}x{orig_h} | MOUSE:({mx},{my}) | "
+               f"GRID=100px | CLICK COORDS = numbers on grid lines")
+        draw2.text((4, 2), hdr, fill=(0, 220, 160))
+
+        # شريط معلومات في الأسفل
+        draw2.rectangle([(0, sh-18), (sw, sh)], fill=(0, 0, 0))
+        draw2.text((4, sh-16),
+                   f"USE REAL COORDS: e.g. click x=500 y=300 means the '500' vertical line + '300' horizontal line",
+                   fill=(180, 180, 80))
+
+        buf = io.BytesIO()
+        final.save(buf, format="JPEG", quality=quality, optimize=True)
+        data = base64.b64encode(buf.getvalue()).decode()
+
+        return {
+            "data": data,
+            "width": orig_w,
+            "height": orig_h,
+            "mouse_x": mx,
+            "mouse_y": my,
+        }
+
+    except Exception as e:
+        print(f"[capture_grid] {e}")
+        plain = capture_screen(scale=scale, quality=quality)
+        mx, my = _get_mouse_pos()
+        w, h = _get_screen_size()
+        return {"data": plain, "width": w, "height": h, "mouse_x": mx, "mouse_y": my}
+
+
+# ─── Command Runner ──────────────────────────────────
+
+def run_raw_command(cmd: str, timeout: int = 60) -> dict:
+    env = {**os.environ, "DISPLAY": DISPLAY,
+           "PYTHONIOENCODING": "utf-8", "LANG": "en_US.UTF-8"}
+    try:
+        result = subprocess.run(cmd, shell=True, capture_output=True,
+                                text=True, timeout=timeout, env=env,
+                                executable="/bin/bash")
+        return {
+            "stdout": result.stdout[-15000:],
+            "stderr": result.stderr[-3000:],
+            "returncode": result.returncode,
+        }
+    except subprocess.TimeoutExpired:
+        return {"stdout": "", "stderr": f"⏱️ Timeout {timeout}s", "returncode": -1}
+    except Exception as e:
+        return {"stdout": "", "stderr": str(e), "returncode": -1}
+
+
+def run_command_smart(cmd: str, timeout: int = 60) -> dict:
+    res = run_raw_command(cmd, timeout=timeout)
+    stdout = res["stdout"].strip()
+
+    if res["returncode"] == 0 and not _is_empty_result(stdout):
+        return res
+
+    is_curl_search = "curl" in cmd and any(x in cmd for x in [
+        "duckduckgo", "google", "bing", "wikipedia", "reddit",
+        "hackernews", "hn.algolia", "arxiv", "news", "search"
+    ])
+
+    if not is_curl_search:
+        return res
+
+    query = _extract_query_from_cmd(cmd)
+    if not query or len(query) < 3:
+        words = [w for w in cmd.split() if len(w) > 3 and not w.startswith('-')
+                 and 'http' not in w and 'python3' not in w and 'curl' not in w]
+        query = ' '.join(words[:5]) if words else ""
+
+    if not query:
+        return res
+
+    sources = _build_search_sources(query)
+    tried_names = []
+    all_results = []
+
+    for source in sources:
+        src_name = source["name"]
+        tried_names.append(f"🔍 {src_name}")
+        src_res = run_raw_command(source["cmd"], timeout=25)
+        src_out = src_res["stdout"].strip()
+
+        if not _is_empty_result(src_out):
+            combined_header = f"[مصدر بديل: {src_name}]\n{'='*50}\n"
+            all_results.append(src_out)
+            for source2 in sources:
+                if source2["name"] != src_name:
+                    s2 = run_raw_command(source2["cmd"], timeout=20)
+                    s2_out = s2["stdout"].strip()
+                    if not _is_empty_result(s2_out):
+                        all_results.append(f"\n[مصدر إضافي: {source2['name']}]\n{s2_out}")
+                        break
+            final_out = combined_header + "\n\n".join(all_results)
+            return {
+                "stdout": final_out[:15000],
+                "stderr": "",
+                "returncode": 0,
+                "_sources_tried": tried_names,
+                "_fallback_used": src_name,
+            }
+
+    return {
+        "stdout": f"[لم تُرجع أي مصادر نتائج لـ: {query}]\nالمصادر: {', '.join(tried_names[:5])}",
+        "stderr": res["stderr"],
+        "returncode": -1,
+        "_sources_tried": tried_names,
+    }
+
+
+def xdo(args: list, timeout=10) -> dict:
+    r = subprocess.run(["xdotool"] + args,
+                       env={**os.environ, "DISPLAY": DISPLAY},
+                       timeout=timeout, capture_output=True, text=True)
+    return {"rc": r.returncode, "out": r.stdout, "err": r.stderr}
+
+
+def type_text_smart(text: str) -> dict:
+    """
+    كتابة نص ذكية — تدعم العربية والإنجليزية:
+    - للنصوص الإنجليزية: xdotool type مباشرة
+    - للنصوص العربية أو المختلطة: xclip clipboard ثم ctrl+v
+    """
+    has_arabic = bool(re.search(r'[\u0600-\u06FF]', text))
+
+    if has_arabic:
+        # طريقة Clipboard لضمان كتابة العربية بشكل صحيح
+        try:
+            proc = subprocess.Popen(
+                ["xclip", "-selection", "clipboard"],
+                stdin=subprocess.PIPE,
+                env={**os.environ, "DISPLAY": DISPLAY}
+            )
+            proc.communicate(text.encode("utf-8"))
+            time.sleep(0.15)
+            # Focus + paste
+            xdo(["key", "--clearmodifiers", "ctrl+v"])
+            return {"success": True, "method": "clipboard+paste", "arabic": True}
+        except Exception as e:
+            # fallback: xdotool type
+            r = xdo(["type", "--clearmodifiers", "--delay", "50", text])
+            return {"success": r["rc"] == 0, "method": "xdotool_fallback", "error": r["err"]}
+    else:
+        # إنجليزية: xdotool type مباشرة
+        r = xdo(["type", "--clearmodifiers", "--delay", "30", text])
+        return {"success": r["rc"] == 0, "method": "xdotool_direct"}
+
+
+def open_browser_smart(url: str = "") -> str:
+    """يفتح المتصفح بطريقة ذكية مع fallback"""
+    browser_cmd = BROWSER
+    if not url:
+        url = "about:blank"
+
+    # جرب أولاً: BROWSER العادي
+    cmd = f"{browser_cmd} --new-window '{url}' &"
+    proc = subprocess.Popen(cmd, shell=True,
+                            env={**os.environ, "DISPLAY": DISPLAY},
+                            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    return f"{browser_cmd} → {url}"
+
+
+# ─── Simple Command Parser ─────────────────────────────
+# يفهم أوامر بسيطة ويحولها لأفعال داخلية
+
+def parse_simple_command(raw: str) -> dict | None:
+    """
+    يُحلّل الأوامر البسيطة النصية وتُعيد action dict
+    أمثلة:
+      open pc          → {"action":"screenshot"}
+      open firefox     → {"action":"open_browser","url":""}
+      open chrome      → {"action":"open_browser","url":""}
+      open browser     → {"action":"open_browser","url":""}
+      open url https://google.com → {"action":"open_browser","url":"https://..."}
+      mouse go x500 y300 → {"action":"mouse_move","x":500,"y":300}
+      mouse go 500 300   → {"action":"mouse_move","x":500,"y":300}
+      click x500 y300    → {"action":"mouse_click","x":500,"y":300,"button":"left"}
+      click 500 300      → {"action":"mouse_click","x":500,"y":300,"button":"left"}
+      rclick x500 y300   → {"action":"mouse_click","x":500,"y":300,"button":"right"}
+      dclick x500 y300   → {"action":"mouse_click","x":500,"y":300,"double":true}
+      type hello world   → {"action":"keyboard_type","text":"hello world"}
+      key enter          → {"action":"keyboard_hotkey","keys":["Return"]}
+      key ctrl+c         → {"action":"keyboard_hotkey","keys":["ctrl","c"]}
+      scroll up          → {"action":"scroll","x":960,"y":540,"clicks":3}
+      scroll down        → {"action":"scroll","x":960,"y":540,"clicks":-3}
+      screenshot         → {"action":"screenshot"}
+      screen info        → {"action":"screen_info"}
+    """
+    s = raw.strip().lower()
+
+    # open pc / open computer / open screen
+    if re.match(r'^open\s+(pc|computer|screen|desktop)$', s):
+        return {"action": "screenshot"}
+
+    # open firefox / chrome / browser / browser url
+    m = re.match(r'^open\s+(firefox|chrome|chromium|browser|web|internet)(\s+(.+))?$', s)
+    if m:
+        url = (m.group(3) or "").strip()
+        if url and not url.startswith("http"):
+            url = "https://" + url
+        return {"action": "open_browser", "url": url or ""}
+
+    # open url <url>
+    m = re.match(r'^open\s+url\s+(\S+)$', s)
+    if m:
+        url = m.group(1)
+        if not url.startswith("http"):
+            url = "https://" + url
+        return {"action": "open_browser", "url": url}
+
+    # mouse go x500 y300  OR  mouse go 500 300
+    m = re.match(r'^mouse\s+(?:go|move|to)\s+x?(\d+)\s+y?(\d+)$', s)
+    if m:
+        return {"action": "mouse_move", "x": int(m.group(1)), "y": int(m.group(2))}
+
+    # click x500 y300  OR  click 500 300
+    m = re.match(r'^click\s+x?(\d+)\s+y?(\d+)$', s)
+    if m:
+        return {"action": "mouse_click", "x": int(m.group(1)), "y": int(m.group(2)), "button": "left"}
+
+    # rclick / right click
+    m = re.match(r'^r(?:ight)?click\s+x?(\d+)\s+y?(\d+)$', s)
+    if m:
+        return {"action": "mouse_click", "x": int(m.group(1)), "y": int(m.group(2)), "button": "right"}
+
+    # dclick / double click
+    m = re.match(r'^d(?:ouble)?click\s+x?(\d+)\s+y?(\d+)$', s)
+    if m:
+        return {"action": "mouse_click", "x": int(m.group(1)), "y": int(m.group(2)), "button": "left", "double": True}
+
+    # type <text>  (يحتفظ بالحالة الأصلية)
+    m = re.match(r'^type\s+(.+)$', raw.strip(), re.IGNORECASE)
+    if m:
+        return {"action": "keyboard_type", "text": m.group(1)}
+
+    # key <keys>
+    m = re.match(r'^key\s+(.+)$', s)
+    if m:
+        k = m.group(1).strip()
+        key_map = {
+            "enter": "Return", "return": "Return", "esc": "Escape", "escape": "Escape",
+            "tab": "Tab", "space": "space", "backspace": "BackSpace", "delete": "Delete",
+            "up": "Up", "down": "Down", "left": "Left", "right": "Right",
+            "home": "Home", "end": "End", "pageup": "Prior", "pagedown": "Next",
+            "f1": "F1", "f2": "F2", "f3": "F3", "f4": "F4", "f5": "F5",
+        }
+        if '+' in k:
+            parts = [p.strip() for p in k.split('+')]
+            keys = [key_map.get(p, p) for p in parts]
+        else:
+            keys = [key_map.get(k, k)]
+        return {"action": "keyboard_hotkey", "keys": keys}
+
+    # scroll up / scroll down / scroll <n>
+    m = re.match(r'^scroll\s+(up|down|(\-?\d+))$', s)
+    if m:
+        w, h = _get_screen_size()
+        direction = m.group(1)
+        if direction == "up":
+            clicks = 4
+        elif direction == "down":
+            clicks = -4
+        else:
+            clicks = int(direction)
+        return {"action": "scroll", "x": w // 2, "y": h // 2, "clicks": clicks}
+
+    # screenshot
+    if s in ("screenshot", "screen", "ss", "snap"):
+        return {"action": "screenshot"}
+
+    # screen info
+    if re.match(r'^screen\s+info$', s):
+        return {"action": "screen_info"}
+
+    return None  # لم يُعرف
+
+
+async def broadcast(msg: dict):
+    txt = json.dumps(msg, ensure_ascii=False)
+    dead = []
+    for ws in active_connections:
+        try: await ws.send_text(txt)
+        except: dead.append(ws)
+    for ws in dead:
+        if ws in active_connections:
+            active_connections.remove(ws)
+
+
+async def screen_stream_loop():
+    global stream_active
+    interval = 1.0 / max(1, stream_fps)
+    while stream_active and active_connections:
+        try:
+            frame = capture_screen(scale=stream_scale, quality=stream_quality)
+            if frame:
+                await broadcast({"type": "frame", "data": frame})
+        except: pass
+        await asyncio.sleep(interval)
+    stream_active = False
+
+
+# ─── Action Handler ──────────────────────────────────
+
+async def handle_action(ws: WebSocket, msg: dict):
+    action = msg.get("action", "")
+    data = msg.get("data", {})
+
+    async def send(obj):
+        await ws.send_text(json.dumps(obj, ensure_ascii=False))
+
+    async def auto_shot_grid(label="", delay=0.5,
+                              force_mx: int | None = None,
+                              force_my: int | None = None):
+        """
+        screenshot مع grid.
+        force_mx/force_my: ارسم الـ cursor في هذا الموضع بالضبط (بعد mouse_move/click)
+        بدلاً من إعادة قراءته من X server — يُصلح race condition.
+        """
+        await asyncio.sleep(delay)
+        result = capture_screen_with_grid(scale=0.65, quality=72,
+                                          force_mx=force_mx, force_my=force_my)
+        if result["data"]:
+            await send({
+                "type": "screenshot",
+                "data": result["data"],
+                "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,
+            })
+        return result["data"]
+
+    # ── screenshot ────────────────────────────────────
+    if action == "screenshot":
+        result = capture_screen_with_grid(scale=0.65, quality=75)
+        await send({
+            "type": "screenshot",
+            "data": result["data"],
+            "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,
+        })
+
+    # ── simple_command — الأوامر البسيطة ──────────────
+    elif action == "simple_command":
+        raw_cmd = data.get("cmd", "").strip()
+        parsed = parse_simple_command(raw_cmd)
+        if parsed is None:
+            await send({
+                "type": "simple_command_result",
+                "ok": False,
+                "cmd": raw_cmd,
+                "error": f"أمر غير معروف: '{raw_cmd}'\nالأوامر المتاحة: open pc, open firefox, mouse go x y, click x y, rclick x y, type TEXT, key ENTER, scroll up/down, screenshot"
+            })
+            return
+        # نفّذ الأمر المُحلّل
+        await send({"type": "simple_command_result", "ok": True, "cmd": raw_cmd, "parsed": parsed})
+        # أعِد تشغيل نفس الـ handle_action مع الأمر المُحلّل
+        sub_msg = {"action": parsed["action"], "data": {k: v for k, v in parsed.items() if k != "action"}}
+        await handle_action(ws, sub_msg)
+        return
+
+    # ── terminal ──────────────────────────────────────
+    elif action == "terminal":
+        cmd = data.get("cmd", "")
+        timeout = int(data.get("timeout", 60))
+        if not cmd:
+            await send({"type": "terminal_result", "cmd": "", "stdout": "",
+                        "stderr": "no command", "returncode": -1})
+            return
+        res = run_command_smart(cmd, timeout=timeout)
+        await send({
+            "type": "terminal_result",
+            "cmd": cmd,
+            "stdout": res["stdout"],
+            "stderr": res.get("stderr", ""),
+            "returncode": res["returncode"],
+            "fallback_used": res.get("_fallback_used", None),
+            "sources_tried": res.get("_sources_tried", []),
+        })
+        await auto_shot_grid(f"بعد: {cmd[:45]}", delay=0.4)
+
+    # ── mouse_move ────────────────────────────────────
+    elif action == "mouse_move":
+        x, y = int(data.get("x", 0)), int(data.get("y", 0))
+        # --sync ينتظر حتى يؤكد X server استلام الأمر
+        xdo(["mousemove", "--sync", str(x), str(y)])
+        await send({"type": "ack", "action": "mouse_move", "x": x, "y": y})
+        # مرّر الإحداثيات مباشرةً لتجنّب race condition مع X server
+        await auto_shot_grid(f"ماوس → ({x},{y})", delay=0.2,
+                             force_mx=x, force_my=y)
+
+    # ── mouse_click ───────────────────────────────────
+    elif action == "mouse_click":
+        x, y = int(data.get("x", 0)), int(data.get("y", 0))
+        btn_num = {"left": "1", "middle": "2", "right": "3"}.get(data.get("button", "left"), "1")
+        xdo(["mousemove", "--sync", str(x), str(y)])
+        await asyncio.sleep(0.08)
+        if data.get("double"):
+            xdo(["click", "--repeat", "2", "--delay", "100", btn_num])
+        else:
+            xdo(["click", btn_num])
+        btn_name = {"1": "left", "2": "middle", "3": "right"}.get(btn_num, "left")
+        await send({"type": "ack", "action": "mouse_click", "x": x, "y": y, "button": btn_name})
+        # مرّر الإحداثيات مباشرةً لتجنّب race condition
+        await auto_shot_grid(f"نقر {btn_name} → ({x},{y})", delay=0.5,
+                             force_mx=x, force_my=y)
+
+    # ── keyboard_type ─────────────────────────────────
+    elif action == "keyboard_type":
+        text = data.get("text", "")
+        if text:
+            result = type_text_smart(text)
+            await send({"type": "ack", "action": "keyboard_type",
+                        "method": result["method"], "text_len": len(text)})
+        else:
+            await send({"type": "ack", "action": "keyboard_type"})
+        await auto_shot_grid("بعد الكتابة", delay=0.5)
+
+    # ── keyboard_hotkey ───────────────────────────────
+    elif action == "keyboard_hotkey":
+        keys = data.get("keys", [])
+        if keys:
+            xdo(["key", "--clearmodifiers", "+".join(keys)])
+        await send({"type": "ack", "action": "keyboard_hotkey", "keys": keys})
+        await auto_shot_grid("بعد الاختصار", delay=0.5)
+
+    # ── keyboard_press ────────────────────────────────
+    elif action == "keyboard_press":
+        key = data.get("key", "")
+        if key:
+            xdo(["key", "--clearmodifiers", key])
+        await send({"type": "ack", "action": "keyboard_press"})
+        await auto_shot_grid("بعد المفتاح", delay=0.4)
+
+    # ── clipboard_write ───────────────────────────────
+    elif action == "clipboard_write":
+        text = data.get("text", "")
+        try:
+            proc = subprocess.Popen(
+                ["xclip", "-selection", "clipboard"],
+                stdin=subprocess.PIPE,
+                env={**os.environ, "DISPLAY": DISPLAY}
+            )
+            proc.communicate(text.encode("utf-8"))
+            await send({"type": "ack", "action": "clipboard_write", "length": len(text)})
+        except Exception as e:
+            await send({"type": "error", "action": "clipboard_write", "msg": str(e)})
+
+    # ── clipboard_read ────────────────────────────────
+    elif action == "clipboard_read":
+        res = run_raw_command("xclip -selection clipboard -o", timeout=5)
+        await send({"type": "clipboard_content", "text": res["stdout"]})
+
+    # ── scroll ────────────────────────────────────────
+    elif action == "scroll":
+        x, y = int(data.get("x", 0)), int(data.get("y", 0))
+        clicks = int(data.get("clicks", 3))
+        btn = "4" if clicks > 0 else "5"
+        xdo(["mousemove", str(x), str(y)])
+        for _ in range(abs(clicks)):
+            xdo(["click", btn])
+            await asyncio.sleep(0.03)
+        await send({"type": "ack", "action": "scroll", "clicks": clicks})
+        await auto_shot_grid("بعد التمرير", delay=0.4)
+
+    # ── open_app ──────────────────────────────────────
+    elif action == "open_app":
+        app_cmd = data.get("cmd", "")
+        if app_cmd:
+            fixed_cmd = app_cmd
+            # إصلاح firefox-esr
+            if "firefox-esr" in app_cmd:
+                esr_check = subprocess.run(["which", "firefox-esr"], capture_output=True, text=True)
+                if esr_check.returncode != 0:
+                    fixed_cmd = app_cmd.replace("firefox-esr", BROWSER)
+
+            subprocess.Popen(fixed_cmd, shell=True,
+                             env={**os.environ, "DISPLAY": DISPLAY},
+                             stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            await send({"type": "ack", "action": "open_app", "cmd": fixed_cmd})
+
+            wait_time = 7.0 if any(x in app_cmd for x in ["firefox", "chromium", "chrome"]) else 4.0
+            await asyncio.sleep(2.0)
+            await auto_shot_grid(f"فتح: {fixed_cmd[:40]} (2s)", delay=0)
+            await asyncio.sleep(wait_time - 2.0)
+            await auto_shot_grid(f"بعد تحميل: {fixed_cmd[:40]}", delay=0)
+        else:
+            await send({"type": "ack", "action": "open_app"})
+
+    # ── open_browser — فتح المتصفح ────────────────────
+    elif action == "open_browser":
+        url = data.get("url", "")
+        if not url:
+            url = "about:blank"
+        browser_result = open_browser_smart(url)
+        await send({"type": "ack", "action": "open_browser", "result": browser_result})
+        await asyncio.sleep(2.0)
+        await auto_shot_grid(f"فتح المتصفح: {url[:50]}", delay=0)
+        await asyncio.sleep(5.0)
+        await auto_shot_grid("بعد تحميل المتصفح", delay=0)
+
+    # ── mouse_drag ────────────────────────────────────
+    elif action == "mouse_drag":
+        x1, y1 = int(data.get("x1", 0)), int(data.get("y1", 0))
+        x2, y2 = int(data.get("x2", 0)), int(data.get("y2", 0))
+        xdo(["mousemove", str(x1), str(y1)])
+        xdo(["mousedown", "1"])
+        await asyncio.sleep(0.1)
+        xdo(["mousemove", str(x2), str(y2)])
+        await asyncio.sleep(0.1)
+        xdo(["mouseup", "1"])
+        await send({"type": "ack", "action": "mouse_drag"})
+        # cursor ينتهي عند x2,y2
+        await auto_shot_grid("بعد السحب", delay=0.4, force_mx=x2, force_my=y2)
+
+    # ── start_stream ──────────────────────────────────
+    elif action == "start_stream":
+        global stream_active, stream_fps, stream_quality, stream_scale
+        stream_fps = int(data.get("fps", 3))
+        stream_quality = int(data.get("quality", 60))
+        stream_scale = float(data.get("scale", 0.5))
+        if not stream_active:
+            stream_active = True
+            asyncio.create_task(screen_stream_loop())
+        await send({"type": "ack", "action": "start_stream"})
+
+    # ── stop_stream ───────────────────────────────────
+    elif action == "stop_stream":
+        stream_active = False
+        await send({"type": "ack", "action": "stop_stream"})
+
+    # ── screen_info ───────────────────────────────────
+    elif action == "screen_info":
+        w, h = _get_screen_size()
+        mx, my = _get_mouse_pos()
+        await send({
+            "type": "screen_info",
+            "width": w, "height": h,
+            "mouse_x": mx, "mouse_y": my,
+            "browser": BROWSER,
+        })
+
+    # ── paste ─────────────────────────────────────────
+    elif action == "paste":
+        text = data.get("text", "")
+        if text:
+            proc = subprocess.Popen(
+                ["xclip", "-selection", "clipboard"],
+                stdin=subprocess.PIPE,
+                env={**os.environ, "DISPLAY": DISPLAY}
+            )
+            proc.communicate(text.encode("utf-8"))
+            await asyncio.sleep(0.1)
+            xdo(["key", "--clearmodifiers", "ctrl+v"])
+        await send({"type": "ack", "action": "paste"})
+        await auto_shot_grid("بعد اللصق", delay=0.5)
+
+    # ── unknown ───────────────────────────────────────
+    else:
+        await send({
+            "type": "error",
+            "msg": f"Unknown action: '{action}'. Available: screenshot, terminal, mouse_move, mouse_click, mouse_drag, keyboard_type, keyboard_hotkey, keyboard_press, clipboard_write, clipboard_read, scroll, open_app, open_browser, paste, simple_command, screen_info, start_stream, stop_stream"
+        })
+
+
+# ─── WebSocket ───────────────────────────────────────
+
+@app.websocket("/ws")
+async def websocket_endpoint(ws: WebSocket):
+    await ws.accept()
+    active_connections.append(ws)
+    w, h = _get_screen_size()
+    await ws.send_text(json.dumps({
+        "type": "connected",
+        "screen_width": w,
+        "screen_height": h,
+        "browser": BROWSER,
+        "msg": f"Z Computer Mode v7 — Smart Control | Browser: {BROWSER} | Screen: {w}x{h}",
+        "commands": [
+            "screenshot", "terminal {cmd}", "mouse_move {x,y}", "mouse_click {x,y,button}",
+            "keyboard_type {text}", "keyboard_hotkey {keys}", "scroll {x,y,clicks}",
+            "open_app {cmd}", "open_browser {url}", "simple_command {cmd}",
+            "Simple cmds: 'open firefox', 'mouse go x y', 'click x y', 'type TEXT', 'key enter'"
+        ]
+    }, ensure_ascii=False))
+    # أرسل screenshot أولية مع grid
+    result = capture_screen_with_grid(scale=0.65, quality=72)
+    if result["data"]:
+        await ws.send_text(json.dumps({
+            "type": "screenshot",
+            "data": result["data"],
+            "ts": int(time.time() * 1000),
+            "label": "الشاشة الأولية",
+            "screen_width": result["width"],
+            "screen_height": result["height"],
+            "mouse_x": result["mouse_x"],
+            "mouse_y": result["mouse_y"],
+            "has_grid": True,
+        }, ensure_ascii=False))
+    try:
+        while True:
+            raw = await ws.receive_text()
+            await handle_action(ws, json.loads(raw))
+    except WebSocketDisconnect:
+        pass
+    except Exception as e:
+        print(f"[ws] {e}")
+    finally:
+        if ws in active_connections:
+            active_connections.remove(ws)
+
+
+# ─── REST ────────────────────────────────────────────
+
+@app.get("/screenshot")
+async def rest_screenshot():
+    result = capture_screen_with_grid(scale=0.7, quality=73)
+    return JSONResponse({
+        "image": result["data"],
+        "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,
+    })
+
+@app.get("/screenshot/clean")
+async def rest_screenshot_clean():
+    return JSONResponse({"image": capture_screen(0.75, 75), "ts": int(time.time() * 1000)})
+
+@app.post("/terminal")
+async def rest_terminal(body: dict):
+    return JSONResponse(run_command_smart(body.get("cmd", ""), body.get("timeout", 60)))
+
+@app.post("/simple")
+async def rest_simple(body: dict):
+    """تنفيذ أمر بسيط عبر REST"""
+    raw = body.get("cmd", "").strip()
+    parsed = parse_simple_command(raw)
+    if not parsed:
+        return JSONResponse({"ok": False, "error": f"Unknown simple command: {raw}"}, status_code=400)
+    return JSONResponse({"ok": True, "parsed": parsed})
+
+@app.get("/health")
+async def health():
+    w, h = _get_screen_size()
+    mx, my = _get_mouse_pos()
+    browser_check = subprocess.run(["which", "firefox-esr"], capture_output=True, text=True)
+    return {
+        "status": "ok",
+        "version": "v7-smart-control",
+        "browser": BROWSER,
+        "firefox_esr_available": browser_check.returncode == 0,
+        "screen_width": w,
+        "screen_height": h,
+        "mouse_x": mx,
+        "mouse_y": my,
+    }
+
+@app.get("/search/{query}")
+async def quick_search(query: str):
+    res = run_command_smart(
+        f"curl -s --max-time 15 'https://api.duckduckgo.com/?q={urllib.parse.quote_plus(query)}&format=json&no_html=1'",
+        timeout=30
+    )
+    return JSONResponse(res)
+
+
+if __name__ == "__main__":
+    port = int(os.environ.get("PORT", 7860))
+    uvicorn.run("app:app", host="0.0.0.0", port=port, log_level="info")
+
+
+

gitattributes (28).txt

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

requirements (26).txt

@@ -0,0 +1,5 @@
+fastapi==0.111.0
+uvicorn[standard]==0.29.0
+websockets==12.0
+Pillow==10.3.0
+python-multipart==0.0.9

start (11).sh

@@ -0,0 +1,92 @@
+#!/bin/bash
+# ══════════════════════════════════════════════════
+# THE Z AI — Computer Mode Startup (FIXED v4)
+# ══════════════════════════════════════════════════
+
+echo "===== Application Startup at $(date '+%Y-%m-%d %H:%M:%S') ====="
+echo "🖥️  Starting Z Computer Mode Server v4..."
+
+# ── 1. Start Virtual Display ─────────────────────
+pkill Xvfb 2>/dev/null || true
+sleep 0.5
+Xvfb :1 -screen 0 1920x1080x24 -ac +extension GLX +render -noreset &
+XVFB_PID=$!
+echo "✅ Xvfb started (PID: $XVFB_PID)"
+sleep 2
+
+# ── 2. Export DISPLAY ────────────────────────────
+export DISPLAY=:1
+export XAUTHORITY=/root/.Xauthority
+touch $XAUTHORITY
+xauth generate :1 . trusted 2>/dev/null || true
+echo "✅ DISPLAY=$DISPLAY"
+
+# ── 3. Start Fluxbox WM ──────────────────────────
+pkill fluxbox 2>/dev/null || true
+fluxbox &
+FLUX_PID=$!
+echo "✅ Fluxbox started (PID: $FLUX_PID)"
+sleep 3
+
+# ── 4. خلفية ملوّنة واضحة بعد Fluxbox ────────────
+# Fluxbox يُلغي xsetroot — نضعها بعده ونكررها
+xsetroot -solid "#1a1a2e" 2>/dev/null || true
+
+# استخدم convert (ImageMagick) لرسم خلفية ملوّنة مع نص واضح
+# حتى يعرف الـ AI أن الشاشة حية وليست سوداء
+convert -size 1920x1080 \
+  gradient:"#1a1a2e-#16213e" \
+  -fill "#00d4aa" \
+  -pointsize 48 \
+  -gravity Center \
+  -annotate 0 "Z AI Computer Mode — Ready" \
+  -fill "#4a90d9" \
+  -pointsize 28 \
+  -gravity South \
+  -annotate 0 "Screen: 1920x1080  |  DISPLAY=:1  |  $(date '+%H:%M:%S')" \
+  /tmp/wallpaper.png 2>/dev/null && \
+  feh --bg-fill /tmp/wallpaper.png 2>/dev/null || \
+  xsetroot -solid "#1a1a2e" 2>/dev/null || true
+
+echo "✅ Wallpaper set"
+
+# ── 5. Verify display works ──────────────────────
+echo "🔍 Testing display..."
+if xdotool getdisplaygeometry 2>/dev/null; then
+    echo "✅ Display working!"
+else
+    echo "⚠️  xdotool test failed — continuing anyway"
+fi
+
+# ── 6. Test screenshot ───────────────────────────
+scrot -q 80 /tmp/test_shot.png 2>/dev/null && \
+    echo "✅ Screenshot test: OK" || \
+    echo "⚠️  scrot test failed"
+
+# ── 7. Detect browser ───────────────────────────
+if command -v firefox-esr &>/dev/null; then
+    echo "✅ Browser: firefox-esr"
+    BROWSER="firefox-esr"
+elif command -v firefox &>/dev/null; then
+    echo "✅ Browser: firefox"
+    BROWSER="firefox"
+elif command -v chromium-browser &>/dev/null; then
+    echo "✅ Browser: chromium-browser"
+    BROWSER="chromium-browser"
+else
+    echo "⚠️  No browser found"
+    BROWSER=""
+fi
+export DEFAULT_BROWSER="$BROWSER"
+
+# ── 8. Pre-warm Firefox (اختياري — يسرّع أول فتح) ─
+if [ -n "$BROWSER" ]; then
+    $BROWSER --headless --no-sandbox about:blank &>/dev/null &
+    sleep 2
+    pkill -f "headless" 2>/dev/null || true
+    echo "✅ Browser pre-warmed"
+fi
+
+echo "🚀 Starting Python API on port ${PORT:-7860}..."
+cd /app
+exec python3 app.py