Update app.py

app.py

@@ -20,6 +20,7 @@ PORT = 7860
 DISPLAY_NUM = ":99"
 WIDTH, HEIGHT = 1280, 720
 
+# Use public STUN/TURN if specific creds fail, but keeping your original config
 TURN_USER = "g08abe68c81a07f098bb5f0914549bb32440e5aad0b216c7fba2b61e76fd62c6"
 TURN_PASS = "aed1a10dd10eba9401ad9d99e5c66036d8a970eab5ba8e6dc9845ab57c771a7d"
 
@@ -33,6 +34,7 @@ class X11Engine:
         self.lock = threading.Lock()
         self.use_damage = False
         self.last_full_refresh = 0
+        self.alive = True
         
         try:
             self.d = display.Display(DISPLAY_NUM)
@@ -42,32 +44,46 @@ class X11Engine:
                 self.use_damage = True
                 logger.info("X11 Damage Extension enabled.")
             else:
-                logger.warning("DAMAGE extension missing. Using polling fallback.")
+                logger.warning("DAMAGE extension missing. Polling mode.")
         except Exception as e:
-            logger.error(f"X11 connection failed: {e}")
+            logger.error(f"X11 Init Failed: {e}")
             self.d = None
 
+    def close(self):
+        """Cleanup resources"""
+        self.alive = False
+        if self.d:
+            try:
+                self.d.close()
+            except:
+                pass
+
     def collect_damage(self):
         if not self.d or not self.use_damage: return
         try:
+            # Check pending events without blocking indefinitely
             while self.d.pending_events() > 0:
                 ev = self.d.next_event()
                 if ev.type == self.d.extension_event.DamageNotify:
                     with self.lock:
                         self.dirty_rects.append((ev.area.x, ev.area.y, ev.area.width, ev.area.height))
                     self.d.damage_subtract(self.damage_ext, 0, 0)
-        except: pass
+        except Exception as e:
+            logger.debug(f"Event error: {e}")
 
     def get_patches(self):
+        if not self.alive: return []
+        
         with self.lock:
-            # Force a full frame every 2 seconds to ensure the client isn't stuck on black
             now = time.time()
-            if now - self.last_full_refresh > 2.0:
+            # Force refresh every 3 seconds or if no damage system
+            if (now - self.last_full_refresh > 3.0) or (not self.use_damage and now - self.last_full_refresh > 0.1):
                 rects = [(0, 0, WIDTH, HEIGHT)]
                 self.last_full_refresh = now
                 self.dirty_rects = []
             elif self.dirty_rects:
-                rects = list(self.dirty_rects[-5:])
+                # Merge small updates or take last 10 to prevent overload
+                rects = list(self.dirty_rects[-10:])
                 self.dirty_rects = []
             else:
                 return []
@@ -75,20 +91,26 @@ class X11Engine:
         patches = []
         for (x, y, w, h) in rects:
             try:
-                # Screen bounds safety
-                x, y = max(0, x), max(0, y)
-                w, h = min(w, WIDTH-x), min(h, HEIGHT-y)
-                if w <= 0 or h <= 0: continue
+                # Sanitize bounds for MSS (Critical to prevent crash)
+                x = max(0, min(x, WIDTH - 1))
+                y = max(0, min(y, HEIGHT - 1))
+                w = max(1, min(w, WIDTH - x))
+                h = max(1, min(h, HEIGHT - y))
                 
                 sct_img = self.sct.grab({"top": y, "left": x, "width": w, "height": h})
+                
+                # Convert to JPEG
                 img = Image.frombytes("RGB", sct_img.size, sct_img.bgra, "raw", "BGRX")
                 buf = BytesIO()
-                img.save(buf, format="JPEG", quality=60)
+                img.save(buf, format="JPEG", quality=60, optimize=True)
+                
                 patches.append({
                     "x": x, "y": y, "w": w, "h": h,
-                    "d": base64.b64encode(buf.getvalue()).decode()
+                    "d": base64.b64encode(buf.getvalue()).decode('ascii')
                 })
-            except: continue
+            except Exception as e:
+                logger.error(f"Capture error: {e}")
+                continue
         return patches
 
     def inject_input(self, msg):
@@ -96,22 +118,42 @@ class X11Engine:
         try:
             t = msg.get("type")
             if t == "mousemove":
-                xtest.fake_motion(self.d, int(msg["x"] * WIDTH), int(msg["y"] * HEIGHT))
+                # Ensure coordinates are within bounds
+                tx = int(max(0, min(msg["x"], 1.0)) * WIDTH)
+                ty = int(max(0, min(msg["y"], 1.0)) * HEIGHT)
+                xtest.fake_motion(self.d, tx, ty)
             elif t == "mousedown":
                 xtest.fake_button_event(self.d, msg.get("button", 0) + 1, True)
             elif t == "mouseup":
                 xtest.fake_button_event(self.d, msg.get("button", 0) + 1, False)
             self.d.sync()
-        except: pass
+        except Exception:
+            pass
 
 async def patch_stream_loop(channel, engine):
-    while channel.readyState == "open":
-        start = time.perf_counter()
-        await asyncio.to_thread(engine.collect_damage)
-        patches = await asyncio.to_thread(engine.get_patches)
-        if patches:
-            channel.send(json.dumps({"type": "patch", "p": patches}))
-        await asyncio.sleep(max(0, 0.033 - (time.perf_counter() - start)))
+    logger.info("Stream started")
+    try:
+        while channel.readyState == "open":
+            start_time = time.perf_counter()
+            
+            # Run X11/MSS operations in a thread to avoid blocking AsyncIO
+            await asyncio.to_thread(engine.collect_damage)
+            patches = await asyncio.to_thread(engine.get_patches)
+            
+            if patches:
+                try:
+                    channel.send(json.dumps({"type": "patch", "p": patches}))
+                except Exception:
+                    break # Channel likely closed
+            
+            # Maintain roughly 30 FPS cap
+            elapsed = time.perf_counter() - start_time
+            await asyncio.sleep(max(0.01, 0.033 - elapsed))
+    except Exception as e:
+        logger.error(f"Stream Loop Error: {e}")
+    finally:
+        logger.info("Stream stopped, cleaning up engine")
+        engine.close()
 
 async def offer(request):
     try:
@@ -121,32 +163,57 @@ async def offer(request):
                          username=TURN_USER, credential=TURN_PASS),
             RTCIceServer(urls=["stun:stun.l.google.com:19302"])
         ]))
+        
+        # Create a new engine for this connection
         engine = X11Engine()
+        
         @pc.on("datachannel")
         def on_dc(channel):
             @channel.on("open")
-            def on_open(): asyncio.create_task(patch_stream_loop(channel, engine))
+            def on_open(): 
+                asyncio.create_task(patch_stream_loop(channel, engine))
+            
             @channel.on("message")
-            def on_message(msg): engine.inject_input(json.loads(msg))
+            def on_message(msg): 
+                engine.inject_input(json.loads(msg))
 
         await pc.setRemoteDescription(RTCSessionDescription(sdp=params["sdp"], type=params["type"]))
         answer = await pc.createAnswer()
         await pc.setLocalDescription(answer)
-        return web.json_response({"sdp": pc.localDescription.sdp, "type": pc.localDescription.type}, 
-                                 headers={"Access-Control-Allow-Origin": "*"})
+        
+        return web.json_response(
+            {"sdp": pc.localDescription.sdp, "type": pc.localDescription.type}, 
+            headers={"Access-Control-Allow-Origin": "*"}
+        )
     except Exception as e:
+        logger.error(f"Offer failed: {e}")
         return web.json_response({"error": str(e)}, status=500)
 
-async def index(request): return web.Response(text="hello world")
-async def options(r): return web.Response(headers={"Access-Control-Allow-Origin": "*", "Access-Control-Allow-Methods": "POST, OPTIONS", "Access-Control-Allow-Headers": "Content-Type"})
+async def index(request):
+    content = open("client2.html", "r").read()
+    return web.Response(content_type="text/html", text=content)
 
 if __name__ == "__main__":
+    # 1. Start Virtual Screen
     os.environ["DISPLAY"] = DISPLAY_NUM
-    subprocess.Popen(["Xvfb", DISPLAY_NUM, "-screen", "0", f"{WIDTH}x{HEIGHT}x24", "+extension", "DAMAGE", "-ac", "-noreset"])
-    time.sleep(5)
-    subprocess.Popen("opera --no-sandbox --disable-gpu --start-maximized", shell=True)
+    logger.info("Starting Xvfb...")
+    xvfb = subprocess.Popen(["Xvfb", DISPLAY_NUM, "-screen", "0", f"{WIDTH}x{HEIGHT}x24", "+extension", "DAMAGE", "-ac", "-noreset"])
+    time.sleep(3) # Wait for X server
+    
+    # 2. Start Opera with Docker-safe flags
+    logger.info("Starting Browser...")
+    # --disable-dev-shm-usage is CRITICAL in Docker
+    browser_cmd = (
+        "opera --no-sandbox --disable-gpu --disable-dev-shm-usage "
+        "--start-maximized --window-size=1280,720 --window-position=0,0 "
+        "--remote-debugging-port=9222"
+    )
+    subprocess.Popen(browser_cmd, shell=True)
+    
+    # 3. Start Web Server
     app = web.Application()
     app.router.add_get("/", index)
     app.router.add_post("/offer", offer)
-    app.router.add_options("/offer", options)
+    
+    logger.info(f"Server running on {HOST}:{PORT}")
     web.run_app(app, host=HOST, port=PORT)