Update app.py

app.py

@@ -7,180 +7,83 @@ import logging
 from aiohttp import web
 from aiortc import RTCPeerConnection, RTCSessionDescription, RTCIceServer, RTCConfiguration
 
-# --- Configuration ---
-HOST = "0.0.0.0"
-PORT = 7860
-VNC_PORT = 5900
-DISPLAY_NUM = ":99"
-
-# Cloudflare TURN to bypass Hugging Face network restrictions
-TURN_USER = "g08abe68c81a07f098bb5f0914549bb32440e5aad0b216c7fba2b61e76fd62c6"
-TURN_PASS = "aed1a10dd10eba9401ad9d99e5c66036d8a970eab5ba8e6dc9845ab57c771a7d"
-
 logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger("HF-VNC-BRIDGE")
-
-# --- System Startup ---
-
-def start_system():
-    """Starts X11, the custom VNC tool, and the browser."""
-    os.environ["DISPLAY"] = DISPLAY_NUM
-    
-    # 1. Start Xvfb with fixed resolution
-    logger.info("Starting Xvfb (1280x720)...")
-    subprocess.Popen([
-        "Xvfb", DISPLAY_NUM, 
-        "-screen", "0", "1280x720x24", 
-        "-ac", "-noreset"
-    ])
+logger = logging.getLogger("X11-FORWARD-BRIDGE")
+
+# Settings
+HOST, PORT = "0.0.0.0", 7860
+DISPLAY = ":99"
+GUACD_PORT = 4822
+
+def start_backend():
+    """Starts Xvfb, guacd (The Protocol Engine), and the App."""
+    os.environ["DISPLAY"] = DISPLAY
+    # 1. Start Xvfb
+    subprocess.Popen(["Xvfb", DISPLAY, "-screen", "0", "1280x720x24", "-ac"])
     time.sleep(1)
-
-    # 2. Start the custom compiled minivnc binary
-    logger.info("Starting custom minivnc tool...")
-    subprocess.Popen(["/usr/local/bin/minivnc"])
+    # 2. Start guacd (Converts X11 to binary drawing commands)
+    subprocess.Popen(["guacd", "-b", "127.0.0.1", "-l", str(GUACD_PORT)])
     time.sleep(1)
-
-    # 3. Start Window Manager (Matchbox)
-    subprocess.Popen("matchbox-window-manager -use_titlebar no", shell=True)
-
-    # 4. Start Browser (Opera)
-    logger.info("Starting Opera...")
-    opera_cmd = (
-        "opera "
-        "--no-sandbox "
-        "--start-maximized "
-        "--user-data-dir=/home/user/opera-data "
-        "--disable-infobars "
-        "--disable-dev-shm-usage "
-        "--disable-gpu "
-        "--no-first-run"
-    )
-    subprocess.Popen(opera_cmd, shell=True)
-
-# --- WebRTC to VNC TCP Bridge ---
-
-async def bridge_vnc_to_datachannel(channel):
-    """Bridges binary VNC (RFB) data between TCP and DataChannel."""
+    # 3. Start Browser
+    subprocess.Popen(f"opera --no-sandbox --start-maximized", shell=True)
+
+async def bridge_guacamole(channel):
+    """
+    Bridges the Guacamole binary protocol (Drawing Commands) 
+    directly to the WebRTC DataChannel.
+    """
     try:
-        # Connect to the local TCP port of minivnc
-        reader, writer = await asyncio.open_connection('127.0.0.1', VNC_PORT)
-        logger.info("Bridge connected to local minivnc.")
-
-        # Flag for connection state
-        closed = asyncio.Event()
-
-        # Task: Local VNC (TCP) -> WebRTC (DataChannel)
-        async def vnc_to_webrtc():
-            try:
-                while not closed.is_set():
-                    # Read large chunks for smoothness
-                    data = await reader.read(65536)
-                    if not data:
-                        break
-                    channel.send(data)
-            except Exception as e:
-                logger.error(f"VNC Read Error: {e}")
-            finally:
-                closed.set()
-
-        # Task: WebRTC (DataChannel) -> Local VNC (TCP)
+        # Connect to local Guacamole Proxy
+        reader, writer = await asyncio.open_connection('127.0.0.1', GUACD_PORT)
+        
+        # Initial Handshake for Guacamole (X11 Connection)
+        # Format: length.value,length.value,...;
+        handshake = f"6.select,3.x11;"
+        writer.write(handshake.encode())
+        await writer.drain()
+
+        # Pipe Guacamole Binary -> WebRTC
+        async def pipe_to_webrtc():
+            while True:
+                data = await reader.read(16384)
+                if not data: break
+                channel.send(data)
+
+        # Pipe WebRTC -> Guacamole Binary
         @channel.on("message")
         def on_message(message):
-            if isinstance(message, bytes):
-                # Standard VNC binary data (mouse/keys)
+            if isinstance(message, str):
+                writer.write(message.encode())
+            elif isinstance(message, bytes):
                 writer.write(message)
-            # Ignore string messages (resize disabled)
-
-        @channel.on("close")
-        def on_close():
-            closed.set()
 
-        await vnc_to_webrtc()
-        
+        await pipe_to_webrtc()
     except Exception as e:
-        logger.error(f"Failed to bridge VNC: {e}")
+        logger.error(f"Bridge Error: {e}")
     finally:
-        if 'writer' in locals():
-            writer.close()
-            await writer.wait_closed()
-
-# --- Web Routes ---
-
-async def index(request):
-    """Requirement: The root URL must only show 'hello world'"""
-    return web.Response(text="hello world")
+        writer.close()
 
 async def offer(request):
-    """Handles WebRTC signaling from the remote client."""
-    try:
-        params = await request.json()
-        offer = RTCSessionDescription(sdp=params["sdp"], type=params["type"])
-    except:
-        return web.Response(status=400)
-
-    # WebRTC Config with STUN and TURN
-    config = RTCConfiguration(iceServers=[
-        RTCIceServer(urls=["stun:stun.l.google.com:19302"]),
-        RTCIceServer(urls=["turns:turn.cloudflare.com:443?transport=tcp", 
-                           "turn:turn.cloudflare.com:3478?transport=udp"], 
-                     username=TURN_USER, credential=TURN_PASS)
-    ])
+    params = await request.json()
+    pc = RTCPeerConnection()
     
-    pc = RTCPeerConnection(config)
-    pcs.add(pc)
-
-    @pc.on("connectionstatechange")
-    async def on_state():
-        if pc.connectionState in ["failed", "closed"]:
-            await pc.close()
-            pcs.discard(pc)
-
     @pc.on("datachannel")
     def on_dc(channel):
-        # Start the TCP bridge when the DataChannel is ready
-        asyncio.create_task(bridge_vnc_to_datachannel(channel))
+        asyncio.create_task(bridge_guacamole(channel))
 
-    await pc.setRemoteDescription(offer)
+    await pc.setRemoteDescription(RTCSessionDescription(sdp=params["sdp"], type=params["type"]))
     answer = await pc.createAnswer()
     await pc.setLocalDescription(answer)
-
+    
     return web.Response(
-        content_type="application/json", 
+        content_type="application/json",
         text=json.dumps({"sdp": pc.localDescription.sdp, "type": pc.localDescription.type}),
-        headers={
-            "Access-Control-Allow-Origin": "*",
-            "Access-Control-Allow-Methods": "POST, OPTIONS",
-            "Access-Control-Allow-Headers": "Content-Type"
-        }
+        headers={"Access-Control-Allow-Origin": "*"}
     )
 
-async def options(request):
-    """Handle CORS pre-flight requests."""
-    return web.Response(headers={
-        "Access-Control-Allow-Origin": "*",
-        "Access-Control-Allow-Methods": "POST, OPTIONS",
-        "Access-Control-Allow-Headers": "Content-Type"
-    })
-
-# --- Main App ---
-
-pcs = set()
-
-async def on_shutdown(app):
-    coros = [pc.close() for pc in pcs]
-    await asyncio.gather(*coros)
-    pcs.clear()
-
 if __name__ == "__main__":
-    # Start the X11 and VNC backend
-    start_system()
-
-    # Start the Web server
+    start_backend()
     app = web.Application()
-    app.on_shutdown.append(on_shutdown)
-    
-    app.router.add_get("/", index)
+    app.router.add_get("/", lambda r: web.Response(text="hello world"))
     app.router.add_post("/offer", offer)
-    app.router.add_options("/offer", options)
-    
     web.run_app(app, host=HOST, port=PORT)