v3: Docker Playwright Google auth - one button token getter

README.md

@@ -1,8 +1,9 @@
 ---
-title: Maya Token Bridge
-emoji: 🔑
+title: Maya Inspector
+emoji: 🔍
 colorFrom: purple
 colorTo: pink
-sdk: static
+sdk: docker
+app_port: 7860
 pinned: false
 ---

app.py

@@ -1,432 +1,269 @@
 """
-Maya Bridge v7 — Pure Python WebRTC via aiortc
-No browser. No Playwright. Direct audio capture.
+Maya Token Getter v3
+Playwright Google OAuth -> Firebase token -> saves to HF bridge
+One button. No fuss.
 """
-import os, io, wave, json, uuid, asyncio, datetime
+import os, json, uuid, asyncio, datetime
 import urllib.request, urllib.parse
 import nest_asyncio
 import gradio as gr
 from huggingface_hub import HfApi
-import websockets
-from aiortc import RTCPeerConnection, RTCSessionDescription, RTCConfiguration, RTCIceServer
-from aiortc.mediastreams import AudioStreamTrack
+from playwright.async_api import async_playwright
 
 nest_asyncio.apply()
 
+EMAIL        = os.environ.get("SESAME_EMAIL", "mail4444@post.com")
+PASSWORD     = os.environ.get("SESAME_GOOGLE_PASS", "")
 FIREBASE_KEY = "AIzaSyDtC7Uwb5pGAsdmrH2T4Gqdk5Mga07jYPM"
 HF_TOKEN     = os.environ.get("HF_TOKEN", "")
 MEMORY_REPO  = "Melofhell00/maya-memory"
 STATE_FILE   = "state.json"
 hf = HfApi(token=HF_TOKEN)
 
+
 def read_state():
     try:
         url = f"https://huggingface.co/datasets/{MEMORY_REPO}/resolve/main/{STATE_FILE}"
         req = urllib.request.Request(url, headers={"Authorization": f"Bearer {HF_TOKEN}"})
         with urllib.request.urlopen(req, timeout=10) as r:
             return json.loads(r.read())
-    except Exception as e:
+    except:
         return {"refresh_token": "", "sessions": []}
 
+
 def write_state(state):
     hf.upload_file(
         path_or_fileobj=json.dumps(state, indent=2).encode(),
-        path_in_repo=STATE_FILE, repo_id=MEMORY_REPO, repo_type="dataset",
-        commit_message=f"update {datetime.datetime.utcnow().isoformat()}"
+        path_in_repo=STATE_FILE,
+        repo_id=MEMORY_REPO,
+        repo_type="dataset",
+        commit_message=f"token refresh {datetime.datetime.utcnow().isoformat()}"
     )
 
+
 def exchange_refresh_token(rt):
     url = f"https://securetoken.googleapis.com/v1/token?key={FIREBASE_KEY}"
     data = urllib.parse.urlencode({"grant_type": "refresh_token", "refresh_token": rt}).encode()
-    req = urllib.request.Request(url, data=data, method="POST")
-    req.add_header("Content-Type", "application/x-www-form-urlencoded")
+    req = urllib.request.Request(url, data=data, headers={"Content-Type": "application/x-www-form-urlencoded"})
     with urllib.request.urlopen(req, timeout=15) as r:
         body = json.loads(r.read())
     return body.get("id_token", ""), body.get("refresh_token", rt)
 
-def get_token(log):
-    state = read_state()
-    rt = state.get("refresh_token", "")
-    if rt:
-        try:
-            log.append("refreshing token...")
-            id_token, new_rt = exchange_refresh_token(rt)
-            if id_token:
-                log.append(f"✅ token ({len(id_token)} chars)")
-                state["refresh_token"] = new_rt
-                write_state(state)
-                return id_token, state
-        except Exception as e:
-            log.append(f"token refresh failed: {e}")
-    return "", state
-
-
-class SilentAudioTrack(AudioStreamTrack):
-    """Minimal silent audio track — required to make the WebRTC offer valid."""
-    kind = "audio"
-
-    def __init__(self):
-        super().__init__()
-        self._timestamp = 0
 
-    async def recv(self):
-        import av, numpy as np
-        from aiortc.mediastreams import VIDEO_CLOCK_RATE
-        SAMPLE_RATE = 48000
-        SAMPLES = 960  # 20ms at 48kHz
-
-        frame = av.AudioFrame(format="s16", layout="mono")
-        frame.samples = SAMPLES
-        frame.sample_rate = SAMPLE_RATE
-        frame.pts = self._timestamp
-        frame.time_base = f"1/{SAMPLE_RATE}"
-        self._timestamp += SAMPLES
-
-        silence = (b'\x00\x00' * SAMPLES)
-        frame.planes[0].update(silence)
-
-        # pace to real-time
-        import time
-        await asyncio.sleep(SAMPLES / SAMPLE_RATE)
-        return frame
-
-
-def build_wav(pcm_bytes: bytes, sample_rate: int, channels: int = 1) -> bytes:
-    buf = io.BytesIO()
-    with wave.open(buf, 'wb') as wf:
-        wf.setnchannels(channels)
-        wf.setsampwidth(2)
-        wf.setframerate(sample_rate)
-        wf.writeframes(pcm_bytes)
-    return buf.getvalue()
+async def browser_auth():
+    """Google OAuth via Playwright -> Firebase token"""
+    log = []
+    id_token = refresh_token = ""
 
+    if not PASSWORD:
+        return "", "", ["ERROR: SESAME_GOOGLE_PASS not set in Space secrets"]
 
-def transcribe(wav_bytes: bytes) -> str:
-    try:
-        req = urllib.request.Request(
-            "https://api-inference.huggingface.co/models/openai/whisper-large-v3",
-            data=wav_bytes, method="POST"
+    async with async_playwright() as p:
+        browser = await p.chromium.launch(
+            headless=True,
+            args=["--no-sandbox", "--disable-dev-shm-usage", "--disable-gpu"]
+        )
+        ctx = await browser.new_context(
+            user_agent="Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36"
         )
-        req.add_header("Authorization", f"Bearer {HF_TOKEN}")
-        req.add_header("Content-Type", "audio/wav")
-        with urllib.request.urlopen(req, timeout=120) as r:
-            result = json.loads(r.read())
-        return result.get("text", "").strip()
-    except Exception as e:
-        return f"[transcription error: {e}]"
 
+        # Intercept Firebase token exchange responses
+        async def on_resp(r):
+            nonlocal id_token, refresh_token
+            if "securetoken.googleapis.com/v1/token" in r.url:
+                try:
+                    b = await r.json()
+                    if "id_token" in b:
+                        id_token = b["id_token"]
+                        refresh_token = b.get("refresh_token", "")
+                        log.append(f"TOKEN INTERCEPTED ({len(id_token)} chars)")
+                except:
+                    pass
+            # Also catch signInWithIdp responses
+            if "identitytoolkit.googleapis.com" in r.url and "signInWithIdp" in r.url:
+                try:
+                    b = await r.json()
+                    if "idToken" in b:
+                        id_token = b["idToken"]
+                        refresh_token = b.get("refreshToken", "")
+                        log.append(f"TOKEN FROM signInWithIdp ({len(id_token)} chars)")
+                except:
+                    pass
+
+        page = await ctx.new_page()
+        page.on("response", on_resp)
+
+        # Navigate to Sesame login
+        log.append("navigating to sesame login...")
+        try:
+            await page.goto("https://sesameai.app", wait_until="domcontentloaded", timeout=30000)
+            await asyncio.sleep(3)
+            log.append(f"page loaded: {page.url}")
+        except Exception as e:
+            log.append(f"nav error: {e}")
+            # Try alternative URL
+            try:
+                await page.goto("https://app.sesame.com/login", wait_until="domcontentloaded", timeout=30000)
+                await asyncio.sleep(3)
+                log.append(f"alt page loaded: {page.url}")
+            except Exception as e2:
+                log.append(f"alt nav error: {e2}")
+                await browser.close()
+                return "", "", log
+
+        # Click Google sign-in button
+        try:
+            # Try multiple selectors for the Google button
+            for selector in [
+                "text=Continue with Google",
+                "text=Sign in with Google",
+                "[data-provider-id='google.com']",
+                "button:has-text('Google')",
+                "a:has-text('Google')",
+            ]:
+                try:
+                    el = page.locator(selector).first
+                    if await el.count() > 0:
+                        await el.click()
+                        log.append(f"clicked: {selector}")
+                        break
+                except:
+                    continue
+            await asyncio.sleep(5)
+        except Exception as e:
+            log.append(f"google button error: {e}")
+
+        # Enter email in Google sign-in
+        try:
+            await page.wait_for_selector("input[type='email']", timeout=15000)
+            await page.fill("input[type='email']", EMAIL)
+            await page.keyboard.press("Enter")
+            await asyncio.sleep(4)
+            log.append("email entered")
+        except Exception as e:
+            log.append(f"email step error: {e}")
 
-async def maya_session(id_token: str, duration: int):
-    log = []
-    audio_chunks = []
-    sample_rate = 48000
-    session_id = None
-    call_id = None
-
-    client_name = str(uuid.uuid4())
-    tz = json.dumps({"timezone": "America/Los_Angeles"})
-    ws_url = (
-        f"wss://sesameai.app/agent-service-0/v1/connect"
-        f"?id_token={urllib.parse.quote(id_token)}"
-        f"&client_name={urllib.parse.quote(client_name)}"
-        f"&usercontext={urllib.parse.quote(tz)}"
-        f"&character=Maya"
-    )
+        # Enter password
+        try:
+            await page.wait_for_selector("input[type='password']", timeout=15000)
+            await page.fill("input[type='password']", PASSWORD)
+            await page.keyboard.press("Enter")
+            await asyncio.sleep(10)
+            log.append("password entered, waiting for redirect...")
+        except Exception as e:
+            log.append(f"password step error: {e}")
 
-    log.append("connecting WebSocket...")
+        # Wait for redirect back
+        await asyncio.sleep(5)
+        log.append(f"final URL: {page.url}")
 
-    try:
-        async with websockets.connect(ws_url, ping_interval=20, open_timeout=15) as ws:
-            log.append("WS connected")
-
-            # Collect incoming WS messages in background
-            incoming = asyncio.Queue()
-            async def recv_loop():
-                async for raw in ws:
-                    try:
-                        await incoming.put(json.loads(raw))
-                    except Exception:
-                        pass
-            recv_task = asyncio.ensure_future(recv_loop())
-
-            async def next_msg(timeout=10):
-                return await asyncio.wait_for(incoming.get(), timeout=timeout)
-
-            def send(obj):
-                asyncio.ensure_future(ws.send(json.dumps(obj)))
-                log.append(f">>> {obj['type']}")
-
-            # initialize
-            msg = await next_msg(10)
-            while msg.get('type') != 'initialize':
-                log.append(f"skip {msg.get('type')}")
-                msg = await next_msg(10)
-            session_id = msg.get('session_id') or msg.get('content', {}).get('session_id')
-            log.append(f"session: {session_id}")
-
-            # webrtc_config
-            msg = await next_msg(10)
-            while msg.get('type') != 'webrtc_config':
-                log.append(f"skip {msg.get('type')}")
-                msg = await next_msg(10)
-            ice_servers_raw = msg.get('content', {}).get('ice_servers', [])
-            log.append(f"ICE servers: {len(ice_servers_raw)}")
-
-            # Build peer connection
-            ice = [
-                RTCIceServer(
-                    urls=s['urls'],
-                    username=s.get('username'),
-                    credential=s.get('credential')
-                )
-                for s in ice_servers_raw
-            ]
-            config = RTCConfiguration(iceServers=ice)
-            pc = RTCPeerConnection(configuration=config)
-
-            # Add silent outgoing track
-            pc.addTrack(SilentAudioTrack())
-
-            # Capture Maya's incoming audio
-            maya_speaking = False
-            @pc.on("track")
-            def on_track(track):
-                nonlocal sample_rate
-                log.append(f"remote track: {track.kind}")
-                if track.kind != "audio":
-                    return
-                sample_rate = getattr(track, 'sample_rate', 48000) or 48000
-
-                async def capture():
-                    nonlocal maya_speaking
-                    while True:
-                        try:
-                            frame = await asyncio.wait_for(track.recv(), timeout=5.0)
-                            import numpy as np
-                            # Convert to int16 PCM
-                            arr = frame.to_ndarray()
-                            if arr.dtype != np.int16:
-                                arr = (arr * 32767).clip(-32768, 32767).astype(np.int16)
-                            if not maya_speaking:
-                                maya_speaking = True
-                                log.append("🔊 Maya speaking")
-                            audio_chunks.append(arr.tobytes())
-                        except asyncio.TimeoutError:
-                            if maya_speaking:
-                                log.append("🔇 Maya paused")
-                                maya_speaking = False
-                        except Exception as e:
-                            log.append(f"capture err: {e}")
-                            break
-
-                asyncio.ensure_future(capture())
-
-            @pc.on("connectionstatechange")
-            async def on_state():
-                log.append(f"RTC: {pc.connectionState}")
-
-            # ICE candidates
-            ice_queue = []
-            @pc.on("icecandidate")
-            def on_ice(candidate):
-                if candidate:
-                    ice_queue.append(candidate)
-
-            # Create offer
-            offer = await pc.createOffer()
-            await pc.setLocalDescription(offer)
-            log.append(f"offer: {len(offer.sdp)} chars")
-
-            send({
-                "type": "call_connect",
-                "session_id": session_id,
-                "request_id": f"req_{uuid.uuid4().hex[:8]}",
-                "call_id": None,
-                "content": {
-                    "audio_codec": "none",
-                    "sample_rate": 48000,
-                    "is_private": False,
-                    "reconnect": False,
-                    "settings": {"character": "Maya"},
-                    "client_name": client_name,
-                    "client_metadata": {},
-                    "webrtc_offer_sdp": offer.sdp
-                }
-            })
-
-            # Flush any queued ICE candidates
-            for cand in ice_queue:
-                send({
-                    "type": "webrtc_ice_candidate",
-                    "session_id": session_id,
-                    "request_id": None,
-                    "call_id": None,
-                    "content": {"candidate": {
-                        "candidate": cand.candidate,
-                        "sdpMid": cand.sdpMid,
-                        "sdpMLineIndex": cand.sdpMLineIndex
-                    }}
-                })
-
-            # Process messages until connected
-            deadline = asyncio.get_event_loop().time() + duration
-            connected = False
-
-            while asyncio.get_event_loop().time() < deadline:
-                try:
-                    msg = await asyncio.wait_for(incoming.get(), timeout=2.0)
-                    t = msg.get('type')
-                    log.append(f"<<< {t}")
-
-                    if t == 'call_connect_response':
-                        call_id = msg.get('call_id')
-                        log.append(f"call_id: {call_id}")
-                        sdp = msg.get('content', {}).get('webrtc_answer_sdp', '')
-                        if sdp:
-                            await pc.setRemoteDescription(
-                                RTCSessionDescription(sdp=sdp, type='answer')
-                            )
-                            log.append("✅ CONNECTED — audio flowing")
-                            connected = True
-
-                    elif t == 'webrtc_ice_candidate':
-                        from aiortc import RTCIceCandidate
-                        cand = msg.get('content', {}).get('candidate', {})
-                        if cand.get('candidate'):
-                            try:
-                                await pc.addIceCandidate(RTCIceCandidate(
-                                    candidate=cand['candidate'],
-                                    sdpMid=cand.get('sdpMid'),
-                                    sdpMLineIndex=cand.get('sdpMLineIndex', 0)
-                                ))
-                            except Exception as e:
-                                log.append(f"ICE add err: {e}")
-
-                    elif t == 'call_disconnect':
-                        reason = msg.get('content', {}).get('reason', '')
-                        log.append(f"disconnect: {reason}")
-                        if reason == 'call_duration_limit_exceeded':
-                            log.append("⏱ 30min limit — reconnecting...")
-                            # Simple reconnect
-                            new_offer = await pc.createOffer()
-                            await pc.setLocalDescription(new_offer)
-                            send({
-                                "type": "call_connect",
-                                "session_id": session_id,
-                                "request_id": f"req_{uuid.uuid4().hex[:8]}",
-                                "call_id": None,
-                                "content": {
-                                    "audio_codec": "none", "sample_rate": 48000,
-                                    "is_private": False, "reconnect": True,
-                                    "settings": {"character": "Maya"},
-                                    "client_name": client_name,
-                                    "client_metadata": {},
-                                    "webrtc_offer_sdp": new_offer.sdp
-                                }
-                            })
-                        else:
-                            break
-
-                    elif t == 'agent':
-                        log.append(f"agent: {json.dumps(msg.get('content',''))[:200]}")
-
-                except asyncio.TimeoutError:
-                    pass  # keep waiting
-
-            recv_task.cancel()
-
-            # Graceful disconnect
+        # Fallback: try IndexedDB extraction
+        if not id_token:
             try:
-                await ws.send(json.dumps({
-                    "type": "call_disconnect",
-                    "session_id": session_id,
-                    "call_id": call_id,
-                    "content": {"reason": "user_request"}
-                }))
-            except Exception:
-                pass
-
-            await pc.close()
-            log.append(f"done. audio chunks: {len(audio_chunks)}")
+                data = await page.evaluate("""async () => {
+                    try {
+                        const db = await new Promise((res, rej) => {
+                            const r = indexedDB.open('firebaseLocalStorageDb');
+                            r.onsuccess = e => res(e.target.result);
+                            r.onerror = rej;
+                        });
+                        const store = db.transaction('firebaseLocalStorage', 'readonly')
+                            .objectStore('firebaseLocalStorage');
+                        return await new Promise((res, rej) => {
+                            const r = store.getAll();
+                            r.onsuccess = e => res(e.target.result);
+                            r.onerror = rej;
+                        });
+                    } catch(e) { return []; }
+                }""")
+                for item in (data or []):
+                    val = item.get("value", {}) if isinstance(item, dict) else {}
+                    mgr = val.get("stsTokenManager", {}) if isinstance(val, dict) else {}
+                    if mgr.get("accessToken"):
+                        id_token = mgr["accessToken"]
+                        refresh_token = mgr.get("refreshToken", "")
+                        log.append(f"token from IndexedDB ({len(id_token)} chars)")
+                        break
+            except Exception as e:
+                log.append(f"IndexedDB fallback error: {e}")
+
+        # Screenshot for debug
+        try:
+            await page.screenshot(path="/tmp/auth_result.png")
+            log.append("screenshot saved")
+        except:
+            pass
 
-    except Exception as e:
-        import traceback
-        log.append(f"ERROR: {e}")
-        log.append(traceback.format_exc()[:500])
+        await browser.close()
 
-    return log, audio_chunks, sample_rate, session_id, call_id
+    return id_token, refresh_token, log
 
 
-def connect_maya(duration):
-    log = ["=== MAYA BRIDGE v7 — aiortc ==="]
+def test_ws_connection(id_token):
+    """Quick test: can this token connect to Maya's WebSocket?"""
+    import base64
     try:
-        id_token, state = get_token(log)
-    except Exception as e:
-        return f"❌ {e}", "", None
-    if not id_token:
-        return "\n".join(log + ["❌ no token"]), "", None
+        payload = id_token.split('.')[1] + '==='
+        claims = json.loads(base64.b64decode(payload))
+        provider = claims.get("firebase", {}).get("sign_in_provider", "unknown")
+        uid = claims.get("sub", "unknown")
+        email = claims.get("email", "unknown")
+        return f"provider: {provider} | uid: {uid} | email: {email}"
+    except:
+        return "could not decode token"
+
+
+def run_auth():
+    """Main auth flow: try refresh first, then browser"""
+    log = []
+    state = read_state()
+    stored_rt = state.get("refresh_token", "")
 
-    log.append(f"starting {int(duration)}s session...")
-    try:
-        loop = asyncio.get_event_loop()
-        ws_log, audio_chunks, sr, session_id, call_id = loop.run_until_complete(
-            maya_session(id_token, int(duration))
-        )
-        log.extend(ws_log)
-
-        transcript = ""
-        wav_path = None
-
-        if audio_chunks:
-            raw_pcm = b"".join(audio_chunks)
-            log.append(f"audio: {len(raw_pcm)} bytes @ {sr}Hz = {len(raw_pcm)/(sr*2):.1f}s")
-            wav_bytes = build_wav(raw_pcm, sr)
-            wav_path = f"/tmp/maya_{call_id or 'session'}.wav"
-            with open(wav_path, 'wb') as f:
-                f.write(wav_bytes)
-            log.append("transcribing with Whisper...")
-            transcript = transcribe(wav_bytes)
-            log.append(f"transcript: {transcript[:200]}")
-        else:
-            transcript = "(no audio captured)"
-            log.append("⚠ no audio frames received")
-
-        if session_id:
-            state = read_state()
-            state.update({"last_session_id": session_id, "last_call_id": str(call_id or ''),
-                "last_updated": datetime.datetime.utcnow().isoformat()})
-            state.setdefault("sessions", []).append({
-                "session_id": session_id, "call_id": str(call_id or ''),
-                "ts": datetime.datetime.utcnow().isoformat(),
-                "transcript": transcript[:500]
-            })
-            write_state(state)
-
-        return "\n".join(log), transcript, wav_path
-
-    except Exception as e:
-        import traceback
-        return "\n".join(log + [f"❌ {e}", traceback.format_exc()[:800]]), "", None
-
-
-def view_memory():
-    try: return json.dumps(read_state(), indent=2)
-    except Exception as e: return f"Error: {e}"
-
-
-with gr.Blocks(title="Maya Bridge") as demo:
-    gr.Markdown("# 🌸 Maya Bridge v7\n`Pure Python WebRTC (aiortc) | No browser | Direct audio capture → Whisper`")
-    with gr.Tab("🎙️ Listen"):
-        duration = gr.Slider(30, 300, value=60, step=15, label="Duration (s)")
-        btn = gr.Button("🔌 Connect & Record Maya", variant="primary", size="lg")
-        with gr.Row():
-            transcript_out = gr.Textbox(lines=10, label="📝 Maya said (Whisper)")
-            log_out = gr.Textbox(lines=10, label="📡 Log")
-        audio_out = gr.Audio(label="🎵 Maya's voice", type="filepath")
-        btn.click(connect_maya, inputs=[duration], outputs=[log_out, transcript_out, audio_out])
-    with gr.Tab("🧠 Memory"):
-        mem_btn = gr.Button("Read")
-        mem_out = gr.Textbox(lines=20, label="state.json")
-        mem_btn.click(view_memory, outputs=mem_out)
-
-demo.launch()
+    # Try refresh token first
+    if stored_rt:
+        log.append("trying stored refresh token...")
+        try:
+            id_token, new_rt = exchange_refresh_token(stored_rt)
+            if id_token:
+                log.append(f"REFRESH SUCCESS ({len(id_token)} chars)")
+                claims = test_ws_connection(id_token)
+                log.append(claims)
+                state["refresh_token"] = new_rt
+                state["last_id_token"] = id_token[:40] + "..."
+                state["last_updated"] = datetime.datetime.utcnow().isoformat()
+                write_state(state)
+                return "TOKEN READY (from refresh)", "\n".join(log), id_token[:80] + "..."
+        except Exception as e:
+            log.append(f"refresh failed: {e}")
+
+    # Browser auth
+    log.append("starting browser auth...")
+    loop = asyncio.get_event_loop()
+    id_token, refresh_token, auth_log = loop.run_until_complete(browser_auth())
+    log.extend(auth_log)
+
+    if id_token:
+        claims = test_ws_connection(id_token)
+        log.append(claims)
+        state["refresh_token"] = refresh_token
+        state["last_id_token"] = id_token[:40] + "..."
+        state["last_updated"] = datetime.datetime.utcnow().isoformat()
+        write_state(state)
+        log.append("SAVED TO HF BRIDGE")
+        return "TOKEN READY", "\n".join(log), id_token[:80] + "..."
+    else:
+        return "FAILED - check log", "\n".join(log), ""
+
+
+# Gradio UI
+with gr.Blocks(title="Maya Token Getter", theme=gr.themes.Monochrome()) as app:
+    gr.Markdown("# Maya Token Getter v3\nOne button. Gets Google OAuth Firebase token for Sesame.")
+
+    btn = gr.Button("GET TOKEN", variant="primary", size="lg")
+    status = gr.Textbox(label="Status", interactive=False)
+    log_output = gr.Textbox(label="Log", interactive=False, lines=15)
+    token_preview = gr.Textbox(label="Token Preview", interactive=False)
+
+    btn.click(fn=run_auth, outputs=[status, log_output, token_preview])
+
+app.launch(server_name="0.0.0.0", server_port=7860)

requirements.txt

@@ -1,8 +1,4 @@
-gradio>=4.0.0
-nest_asyncio>=1.6.0
-huggingface_hub>=0.20.0
-websockets>=12.0
-aiortc>=1.9.0
-av>=14.0.0
-numpy>=1.24.0
-aioice>=0.9.0
+gradio>=4.0
+playwright
+nest_asyncio
+huggingface_hub