Update app.py

app.py

@@ -9,10 +9,7 @@ import concurrent.futures
 import threading
 import numpy as np
 import uuid
-import pty
-import fcntl
-import termios
-import struct
+import psutil
 from aiohttp import web
 from aiortc import RTCPeerConnection, RTCSessionDescription, VideoStreamTrack, RTCIceServer, RTCConfiguration
 from av import VideoFrame
@@ -32,7 +29,7 @@ TURN_USER = "g08abe68c81a07f098bb5f0914549bb32440e5aad0b216c7fba2b61e76fd62c6"
 TURN_PASS = "aed1a10dd10eba9401ad9d99e5c66036d8a970eab5ba8e6dc9845ab57c771a7d"
 
 logging.basicConfig(level=logging.WARNING) 
-logger = logging.getLogger("WebRTC-System")
+logger = logging.getLogger("WebRTC-Antigravity")
 
 executor = concurrent.futures.ThreadPoolExecutor(max_workers=16)
 thread_local_storage = threading.local()
@@ -42,139 +39,6 @@ config = {
     "height": DEFAULT_HEIGHT
 }
 
-class ClipboardManager:
-    def __init__(self):
-        self.last_content = ""
-        self.channels = set()
-        self.lock = threading.Lock()
-        self.running = True
-        self.thread = threading.Thread(target=self.monitor_loop, daemon=True)
-        self.thread.start()
-
-    def add_channel(self, channel):
-        with self.lock:
-            self.channels.add(channel)
-
-    def remove_channel(self, channel):
-        with self.lock:
-            self.channels.discard(channel)
-
-    def update_x11(self, content):
-        if content == self.last_content: 
-            return
-        
-        self.last_content = content
-        try:
-            env = os.environ.copy()
-            env["DISPLAY"] = DISPLAY_NUM
-            
-            p = subprocess.Popen(
-                ['xclip', '-i', '-selection', 'clipboard'], 
-                stdin=subprocess.PIPE, 
-                env=env
-            )
-            p.communicate(input=content.encode('utf-8'))
-        except Exception as e:
-            logger.error(f"Clipboard Write Error: {e}")
-
-    def monitor_loop(self):
-        while self.running:
-            try:
-                if not os.environ.get("DISPLAY"):
-                    os.environ["DISPLAY"] = DISPLAY_NUM
-
-                try:
-                    curr = subprocess.check_output(
-                        ['xclip', '-o', '-selection', 'clipboard'], 
-                        stderr=subprocess.DEVNULL,
-                        timeout=0.5
-                    ).decode('utf-8')
-                except:
-                    curr = ""
-
-                if curr and curr != self.last_content:
-                    self.last_content = curr
-                    self.broadcast(curr)
-
-            except Exception:
-                pass
-            time.sleep(1.0)
-
-    def broadcast(self, content):
-        msg = json.dumps({"type": "clipboard", "content": content})
-        with self.lock:
-            for ch in list(self.channels):
-                try:
-                    if ch.readyState == "open":
-                        ch.send(msg)
-                    else:
-                        self.channels.discard(ch)
-                except:
-                    self.channels.discard(ch)
-
-clipboard_manager = ClipboardManager()
-
-class Terminal:
-    def __init__(self, channel):
-        self.channel = channel
-        self.master_fd, self.slave_fd = pty.openpty()
-        self.pid = os.fork()
-
-        if self.pid == 0:
-            os.close(self.master_fd)
-            os.setsid()
-            os.dup2(self.slave_fd, 0)
-            os.dup2(self.slave_fd, 1)
-            os.dup2(self.slave_fd, 2)
-            if self.slave_fd > 2:
-                os.close(self.slave_fd)
-            
-            os.environ["TERM"] = "xterm-256color"
-            os.environ["DISPLAY"] = DISPLAY_NUM
-            os.environ["HOME"] = "/home/user"
-            
-            shell = "/bin/bash"
-            os.execl(shell, shell)
-        else:
-            os.close(self.slave_fd)
-            self.loop = asyncio.get_running_loop()
-            self.loop.add_reader(self.master_fd, self.read_output)
-            self.channel.on("close", self.close)
-
-    def read_output(self):
-        try:
-            data = os.read(self.master_fd, 4096)
-            if data:
-                self.channel.send(data.decode('utf-8', 'ignore'))
-        except OSError:
-            self.close()
-
-    def write_input(self, data):
-        if self.master_fd:
-            try:
-                if data.startswith('{"type":"resize"'):
-                    try:
-                        cmd = json.loads(data)
-                        self.resize(cmd.get("rows", 24), cmd.get("cols", 80))
-                    except: pass
-                else:
-                    os.write(self.master_fd, data.encode('utf-8'))
-            except Exception as e:
-                logger.error(f"PTY Write Error: {e}")
-
-    def resize(self, rows, cols):
-        try:
-            winsize = struct.pack("HHHH", rows, cols, 0, 0)
-            fcntl.ioctl(self.master_fd, termios.TIOCSWINSZ, winsize)
-        except: pass
-
-    def close(self):
-        try:
-            self.loop.remove_reader(self.master_fd)
-            os.close(self.master_fd)
-            os.kill(self.pid, 9)
-        except: pass
-
 class InputManager:
     def __init__(self):
         self.process = None
@@ -182,30 +46,36 @@ class InputManager:
         self.scroll_accum = 0
 
     def start_process(self):
-        if not os.environ.get("DISPLAY"): return
+        if not os.environ.get("DISPLAY"):
+            return
+
         try:
-            self.process = subprocess.Popen(['xdotool', '-'], stdin=subprocess.PIPE, encoding='utf-8', bufsize=0)
-        except Exception as e: logger.error(f"Failed to start xdotool: {e}")
+            self.process = subprocess.Popen(
+                ['xdotool', '-'], 
+                stdin=subprocess.PIPE, 
+                encoding='utf-8', 
+                bufsize=0 
+            )
+        except Exception as e:
+            logger.error(f"Failed to start xdotool: {e}")
 
     def _send_raw(self, command):
-        if self.process is None or self.process.poll() is not None: self.start_process()
+        if self.process is None or self.process.poll() is not None:
+            self.start_process()
+        
         if self.process:
             try:
                 self.process.stdin.write(command + "\n")
                 self.process.stdin.flush()
-            except:
+            except Exception:
                 try: self.process.kill()
                 except: pass
                 self.process = None
 
     def send(self, command):
-        with self.lock: self._send_raw(command)
+        with self.lock:
+            self._send_raw(command)
 
-    def mouse_move(self, x, y): self.send(f"mousemove {x} {y}")
-    def mouse_down(self, btn): self.send(f"mousedown {btn}")
-    def mouse_up(self, btn): self.send(f"mouseup {btn}")
-    def key_down(self, key): self.send(f"keydown {key}")
-    def key_up(self, key): self.send(f"keyup {key}")
     def scroll(self, dy):
         with self.lock:
             self.scroll_accum += dy
@@ -217,85 +87,205 @@ class InputManager:
                 self._send_raw("click 4")
                 self.scroll_accum += THRESHOLD
 
+    def mouse_move(self, x, y): self.send(f"mousemove {x} {y}")
+    def mouse_down(self, btn): self.send(f"mousedown {btn}")
+    def mouse_up(self, btn): self.send(f"mouseup {btn}")
+    def click(self, btn, repeat=1): self.send(f"click --repeat {repeat} {btn}")
+    def key_down(self, key): self.send(f"keydown {key}")
+    def key_up(self, key): self.send(f"keyup {key}")
+
 input_manager = InputManager()
 
 def start_system():
     os.environ["DISPLAY"] = DISPLAY_NUM
+
     if not shutil.which("Xvfb"): raise FileNotFoundError("Xvfb missing")
     
-    logger.warning(f"Starting Xvfb on {DISPLAY_NUM}...")
-    subprocess.Popen(["Xvfb", DISPLAY_NUM, "-screen", "0", f"{MAX_WIDTH}x{MAX_HEIGHT}x24", "-ac", "-noreset"])
-    time.sleep(2)
+    subprocess.Popen([
+        "Xvfb", DISPLAY_NUM, 
+        "-screen", "0", f"{MAX_WIDTH}x{MAX_HEIGHT}x24",
+        "-ac", "-noreset"
+    ])
+    
+    time.sleep(3)
+
     input_manager.start_process()
+
     set_resolution(DEFAULT_WIDTH, DEFAULT_HEIGHT)
-    
+
     if shutil.which("matchbox-window-manager"):
         subprocess.Popen("matchbox-window-manager -use_titlebar no", shell=True)
 
+    threading.Thread(target=maintain_antigravity, daemon=True).start()
+
+def maintain_antigravity():
+    while True:
+        chrome_running = False
+        for proc in psutil.process_iter(['name']):
+            try:
+                if 'chrome' in proc.info['name']:
+                    chrome_running = True
+                    break
+            except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+                pass
+        
+        if not chrome_running:
+            subprocess.Popen(["python", "-m", "antigravity"])
+            time.sleep(5)
+        
+        time.sleep(2)
+
+def get_xrandr_output_name():
+    try:
+        out = subprocess.check_output(["xrandr"]).decode()
+        for line in out.splitlines():
+            if " connected" in line:
+                return line.split()[0]
+    except: pass
+    return "screen"
+
+def get_cvt_modeline(width, height, rate=60):
+    H_BLANK = 160
+    H_SYNC = 32
+    H_FRONT_PORCH = 48
+    V_FRONT_PORCH = 3
+    V_SYNC = 5
+    MIN_V_BLANK = 460
+    
+    frame_time_us = 1000000.0 / rate
+    active_time_us = frame_time_us - MIN_V_BLANK
+    if active_time_us <= 0: return None
+    
+    h_period_us = active_time_us / height
+    v_blank_lines = int(MIN_V_BLANK / h_period_us) + 1
+    v_total = height + v_blank_lines
+    h_total = width + H_BLANK
+    pclk = (h_total * v_total * rate) / 1000000.0
+    
+    h_sync_start = width + H_FRONT_PORCH
+    h_sync_end = h_sync_start + H_SYNC
+    v_sync_start = height + V_FRONT_PORCH
+    v_sync_end = v_sync_start + V_SYNC
+    
+    return f'"{width}x{height}_60.00" {pclk:.2f} {width} {h_sync_start} {h_sync_end} {h_total} {height} {v_sync_start} {v_sync_end} {v_total} +hsync -vsync'
+
 def set_resolution(w, h):
     try:
         if w % 2 != 0: w += 1
         if h % 2 != 0: h += 1
+
+        output = get_xrandr_output_name()
+        mode_name = f"WEB_{w}x{h}_{str(uuid.uuid4())[:4]}"
+        modeline_str = get_cvt_modeline(w, h)
+        if not modeline_str: return
+            
+        parts = modeline_str.split()
+        mode_params = parts[1:]
+
+        subprocess.run(["xrandr", "--newmode", mode_name] + mode_params, check=True)
+        subprocess.run(["xrandr", "--addmode", output, mode_name], check=True)
+        subprocess.run(["xrandr", "--output", output, "--mode", mode_name], check=True)
+        
         config["width"] = w
         config["height"] = h
-    except: pass
+    except Exception as e:
+        logger.error(f"Resolution setup failed: {e}")
 
 class VirtualScreenTrack(VideoStreamTrack):
     kind = "video"
     def __init__(self):
         super().__init__()
         self.last_frame_time = 0
+        self.frame_count = 0
 
     def _capture(self):
         try:
             if not hasattr(thread_local_storage, "sct"):
                 thread_local_storage.sct = mss.mss()
+            
             monitor = {"top": 0, "left": 0, "width": config["width"], "height": config["height"]}
-            return np.array(thread_local_storage.sct.grab(monitor))[..., :3]
+            sct_img = thread_local_storage.sct.grab(monitor)
+            img = np.array(sct_img)
+            return img[..., :3] 
         except: return None
 
     async def recv(self):
         FPS = 30
         FRAME_TIME = 1.0 / FPS
+        
         pts, time_base = await self.next_timestamp()
         
         current_time = time.time()
         wait = FRAME_TIME - (current_time - self.last_frame_time)
-        if wait > 0: await asyncio.sleep(wait)
+        if wait > 0:
+            await asyncio.sleep(wait)
+        
         self.last_frame_time = time.time()
 
         frame = await asyncio.get_event_loop().run_in_executor(executor, self._capture)
+        
         if frame is None:
             blank = np.zeros((config["height"], config["width"], 3), dtype=np.uint8)
             av_frame = VideoFrame.from_ndarray(blank, format="bgr24")
         else:
             av_frame = VideoFrame.from_ndarray(frame, format="bgr24")
-        
+
         av_frame.pts = pts
         av_frame.time_base = time_base
         return av_frame
 
+def map_key(key):
+    if key == " ": return "space"
+    k = key.lower()
+    charmap = {
+        "control": "ctrl", "shift": "shift", "alt": "alt", "meta": "super", "cmd": "super",
+        "enter": "Return", "backspace": "BackSpace", "tab": "Tab", "escape": "Escape",
+        "arrowup": "Up", "arrowdown": "Down", "arrowleft": "Left", "arrowright": "Right",
+        "home": "Home", "end": "End", "pageup": "Page_Up", "pagedown": "Page_Down",
+        "delete": "Delete", "insert": "Insert",
+        "f1": "F1", "f2": "F2", "f3": "F3", "f4": "F4", "f5": "F5", "f6": "F6",
+        "f7": "F7", "f8": "F8", "f9": "F9", "f10": "F10", "f11": "F11", "f12": "F12",
+        "!": "exclam", "@": "at", "#": "numbersign", "$": "dollar", "%": "percent",
+        "^": "asciicircum", "&": "ampersand", "*": "asterisk", "(": "parenleft",
+        ")": "parenright", "-": "minus", "_": "underscore", "=": "equal", "+": "plus",
+        "[": "bracketleft", "{": "braceleft", "]": "bracketright", "}": "braceright",
+        ";": "semicolon", ":": "colon", "'": "apostrophe", "\"": "quotedbl",
+        ",": "comma", "<": "less", ".": "period", ">": "greater", "/": "slash",
+        "?": "question", "\\": "backslash", "|": "bar", "`": "grave", "~": "asciitilde",
+        " ": "space"
+    }
+    return charmap.get(k, k)
+
 def process_input(data):
     try:
         msg = json.loads(data)
         t = msg.get("type")
-        w, h = config["width"], config["height"]
         
-        if t == "clipboard":
-            clipboard_manager.update_x11(msg.get("content", ""))
-        elif t == "mousemove": 
-            input_manager.mouse_move(int(msg["x"]*w), int(msg["y"]*h))
-        elif t == "mousedown": 
+        current_w = config["width"]
+        current_h = config["height"]
+
+        if t == "resize":
+            target_w = int(msg.get("width"))
+            target_h = int(msg.get("height"))
+            set_resolution(target_w, target_h)
+
+        elif t == "mousemove":
+            input_manager.mouse_move(int(msg["x"] * current_w), int(msg["y"] * current_h))
+        elif t == "mousedown":
             input_manager.mouse_down({0:1, 1:2, 2:3}.get(msg.get("button"), 1))
-        elif t == "mouseup": 
+        elif t == "mouseup":
             input_manager.mouse_up({0:1, 1:2, 2:3}.get(msg.get("button"), 1))
-        elif t == "keydown": 
-            input_manager.key_down(msg.get("key"))
-        elif t == "keyup": 
-            input_manager.key_up(msg.get("key"))
         elif t == "wheel":
             input_manager.scroll(msg.get("deltaY", 0))
-    except: pass
+        elif t == "keydown":
+            k = map_key(msg.get("key"))
+            if k: input_manager.key_down(k)
+        elif t == "keyup":
+            k = map_key(msg.get("key"))
+            if k: input_manager.key_up(k)
+
+    except Exception:
+        pass 
 
 async def offer(request):
     try:
@@ -305,7 +295,7 @@ async def offer(request):
 
     pc = RTCPeerConnection(RTCConfiguration(iceServers=[
         RTCIceServer(urls=["turns:turn.cloudflare.com:443?transport=tcp", "turn:turn.cloudflare.com:3478?transport=udp"], username=TURN_USER, credential=TURN_PASS),
-        RTCIceServer(urls=["stun:stun.l.google.com:19302"])
+        RTCIceServer(urls=["stun:stun.l.google.com:19302"]) 
     ]))
     pcs.add(pc)
 
@@ -317,21 +307,17 @@ async def offer(request):
 
     @pc.on("datachannel")
     def on_dc(channel):
-        if channel.label == "input":
-            clipboard_manager.add_channel(channel)
-            channel.on("message", lambda m: asyncio.get_event_loop().run_in_executor(executor, process_input, m))
-            channel.on("close", lambda: clipboard_manager.remove_channel(channel))
-        elif channel.label == "terminal":
-            term = Terminal(channel)
-            channel.on("message", term.write_input)
+        channel.on("message", lambda m: asyncio.get_event_loop().run_in_executor(executor, process_input, m))
 
     pc.addTrack(VirtualScreenTrack())
     await pc.setRemoteDescription(offer)
     answer = await pc.createAnswer()
     await pc.setLocalDescription(answer)
-    return web.Response(content_type="application/json", text=json.dumps({"sdp": pc.localDescription.sdp, "type": pc.localDescription.type}), headers={"Access-Control-Allow-Origin": "*"})
 
-async def index(r): return web.Response(text="WebRTC Backend Running")
+    sdp = "\r\n".join([l for l in pc.localDescription.sdp.splitlines() if "a=candidate" not in l or "typ relay" in l]) + "\r\n"
+    return web.Response(content_type="application/json", text=json.dumps({"sdp": sdp, "type": pc.localDescription.type}), headers={"Access-Control-Allow-Origin": "*"})
+
+async def index(r): return web.Response(text="helloworld")
 async def options(r): return web.Response(headers={"Access-Control-Allow-Origin": "*", "Access-Control-Allow-Methods": "POST, OPTIONS", "Access-Control-Allow-Headers": "Content-Type"})
 
 pcs = set()