Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
feat(playground): persist ChatGPT login through Moli
ldm037ddcd6952d5
diff --git a/moli-playground/chatgpt/chatgpt_auth_bridge.py b/moli-playground/chatgpt/chatgpt_auth_bridge.pynew file mode 100644index 000000000..bf5031d94--- /dev/null+++ b/moli-playground/chatgpt/chatgpt_auth_bridge.py@@ -0,0 +1,579 @@+from __future__ import annotations++import argparse+import asyncio+import json+import os+import re+import shutil+import signal+import subprocess+import tempfile+import time+from collections.abc import Callable+from dataclasses import dataclass+from pathlib import Path+from typing import Any++from chatgpt_cdp_demo import DemoError, read_json_url_no_proxy, reserve_local_port+from chatgpt_playwright_core import (+ PlaywrightChatGPTSession,+ auth_blocking_reason_from_url,+)++Reporter = Callable[[str], None]+PROFILE_METADATA_FILE = ".chatgpt-playground-auth.json"+++@dataclass(frozen=True)+class ChromiumAuthState:+ cookies: list[dict[str, object]]+ local_storage: list[list[str]]+ user_agent: str+++def default_moli_chatgpt_profile_dir() -> Path:+ data_home = os.environ.get("XDG_DATA_HOME")+ root = (+ Path(data_home).expanduser() if data_home else Path.home() / ".local" / "share"+ )+ return root / "moli" / "chatgpt-profile"+++def prepare_profile_dir(profile_dir: str | os.PathLike[str]) -> Path:+ path = Path(profile_dir).expanduser().resolve()+ path.mkdir(mode=0o700, parents=True, exist_ok=True)+ path.chmod(0o700)+ return path+++def load_profile_user_agent(profile_dir: str | os.PathLike[str]) -> str:+ path = Path(profile_dir).expanduser().resolve() / PROFILE_METADATA_FILE+ try:+ payload = json.loads(path.read_text(encoding="utf-8"))+ except (OSError, ValueError, TypeError):+ return ""+ if not isinstance(payload, dict):+ return ""+ user_agent = payload.get("user_agent")+ return user_agent if isinstance(user_agent, str) else ""+++def save_profile_user_agent(+ profile_dir: str | os.PathLike[str], user_agent: str+) -> None:+ directory = prepare_profile_dir(profile_dir)+ target = directory / PROFILE_METADATA_FILE+ descriptor, temporary_name = tempfile.mkstemp(+ prefix=f"{PROFILE_METADATA_FILE}.", dir=directory+ )+ temporary = Path(temporary_name)+ try:+ os.fchmod(descriptor, 0o600)+ with os.fdopen(descriptor, "w", encoding="utf-8") as handle:+ json.dump(+ {"user_agent": user_agent}, handle, ensure_ascii=False, sort_keys=True+ )+ handle.write("\n")+ temporary.replace(target)+ target.chmod(0o600)+ except BaseException:+ try:+ os.close(descriptor)+ except OSError:+ pass+ temporary.unlink(missing_ok=True)+ raise+++def chromium_cookie_params(cookies: list[dict[str, Any]]) -> list[dict[str, object]]:+ result: list[dict[str, object]] = []+ for cookie in cookies:+ domain = str(cookie.get("domain") or "")+ if "chatgpt.com" not in domain and "openai.com" not in domain:+ continue+ item: dict[str, object] = {+ "name": str(cookie.get("name") or ""),+ "value": str(cookie.get("value") or ""),+ "domain": domain,+ "path": str(cookie.get("path") or "/"),+ "secure": bool(cookie.get("secure")),+ "httpOnly": bool(cookie.get("httpOnly")),+ }+ expires = cookie.get("expires")+ if isinstance(expires, (int, float)) and expires > 0:+ item["expires"] = expires+ same_site = cookie.get("sameSite")+ if same_site in {"Strict", "Lax", "None"}:+ item["sameSite"] = same_site+ result.append(item)+ return result+++def resolve_auth_chromium(args: argparse.Namespace) -> Path:+ configured = str(+ getattr(args, "auth_chromium_bin", "")+ or getattr(args, "chromium_bin", "")+ or os.environ.get("CHROMIUM_BIN")+ or ""+ )+ if configured:+ candidate = Path(configured).expanduser().resolve()+ if candidate.is_file():+ return candidate+ raise DemoError(f"authentication Chromium binary does not exist: {candidate}")+ for name in (+ "chromium",+ "chromium-browser",+ "google-chrome",+ "google-chrome-stable",+ ):+ resolved = shutil.which(name)+ if resolved:+ return Path(resolved).resolve()+ raise DemoError(+ "Chromium is required for ChatGPT authentication; pass --auth-chromium-bin"+ )+++def resolve_xvfb() -> Path:+ configured = os.environ.get("XVFB_BIN") or ""+ if configured:+ candidate = Path(configured).expanduser().resolve()+ if candidate.is_file():+ return candidate+ raise DemoError(f"Xvfb binary does not exist: {candidate}")+ resolved = shutil.which("Xvfb")+ if resolved:+ return Path(resolved).resolve()+ raise DemoError("Xvfb is required for headful ChatGPT authentication")+++def auth_proxy_options(args: argparse.Namespace) -> tuple[str, str]:+ proxy = str(+ getattr(args, "http_proxy", "")+ or os.environ.get("HTTPS_PROXY")+ or os.environ.get("https_proxy")+ or os.environ.get("HTTP_PROXY")+ or os.environ.get("http_proxy")+ or ""+ )+ no_proxy = str(+ getattr(args, "http_no_proxy", "")+ or os.environ.get("NO_PROXY")+ or os.environ.get("no_proxy")+ or ""+ )+ return proxy, no_proxy+++def terminate_process_group(process: subprocess.Popen[Any] | None) -> None:+ if process is None or process.poll() is not None:+ return+ try:+ os.killpg(process.pid, signal.SIGTERM)+ except ProcessLookupError:+ return+ try:+ process.wait(timeout=3)+ except subprocess.TimeoutExpired:+ try:+ os.killpg(process.pid, signal.SIGKILL)+ except ProcessLookupError:+ pass+ process.wait(timeout=3)+++def remove_auth_profile(path: Path | None) -> None:+ if path is None or not path.exists():+ return+ resolved = path.resolve()+ temporary_root = Path(tempfile.gettempdir()).resolve()+ if resolved.parent != temporary_root or not resolved.name.startswith(+ "moli-chatgpt-auth-chromium."+ ):+ raise DemoError(+ f"refusing to remove unexpected authentication profile: {resolved}"+ )+ shutil.rmtree(resolved)+++def start_xvfb() -> tuple[subprocess.Popen[str], str]:+ process = subprocess.Popen( # noqa: S603 - executable is resolved from an explicit trusted path.+ [+ str(resolve_xvfb()),+ "-displayfd",+ "1",+ "-screen",+ "0",+ "1440x1000x24",+ "-nolisten",+ "tcp",+ ],+ stdout=subprocess.PIPE,+ stderr=subprocess.DEVNULL,+ text=True,+ start_new_session=True,+ )+ if process.stdout is None:+ terminate_process_group(process)+ raise DemoError("Xvfb stdout pipe is unavailable")+ display_number = process.stdout.readline().strip()+ if not display_number or process.poll() is not None:+ terminate_process_group(process)+ raise DemoError("Xvfb did not allocate a display for ChatGPT authentication")+ return process, f":{display_number}"+++async def wait_for_chromium_cdp(+ endpoint: str, process: subprocess.Popen[bytes], timeout: float+) -> str:+ deadline = time.monotonic() + timeout+ last_error: BaseException | None = None+ while time.monotonic() < deadline:+ if process.poll() is not None:+ return_code = process.returncode+ raise DemoError(+ f"authentication Chromium exited before CDP startup: rc={return_code}"+ )+ try:+ version = await asyncio.to_thread(+ read_json_url_no_proxy, endpoint + "/json/version"+ )+ websocket_url = version.get("webSocketDebuggerUrl")+ if isinstance(websocket_url, str) and websocket_url:+ return websocket_url+ except BaseException as error: # noqa: BLE001 - report the final startup error.+ last_error = error+ await asyncio.sleep(0.1)+ raise DemoError(+ "timed out waiting for authentication Chromium CDP; "+ f"last_error={type(last_error).__name__ if last_error else 'none'}"+ )+++async def click_visible_text(page: Any, patterns: tuple[str, ...]) -> bool:+ interactive = page.locator("button, [role='button'], a, label")+ for pattern in patterns:+ expression = re.compile(pattern, re.IGNORECASE)+ for candidates in (+ interactive.filter(has_text=expression),+ page.get_by_text(expression),+ ):+ for index in range(min(await candidates.count(), 12)):+ candidate = candidates.nth(index)+ try:+ if await candidate.is_visible(+ timeout=500+ ) and await candidate.is_enabled(timeout=500):+ await candidate.click(timeout=5000)+ return True+ except Exception: # noqa: BLE001, S112 - probe the next visible candidate.+ continue+ return False+++async def select_push_mfa(+ session: PlaywrightChatGPTSession, reporter: Reporter+) -> None:+ if session.page is None:+ raise DemoError("MFA page is unavailable")+ push_patterns = (+ r"push notification",+ r"chatgpt app",+ r"approve.*device",+ r"push",+ )+ clicked = await click_visible_text(session.page, push_patterns)+ if not clicked:+ expanded = await click_visible_text(+ session.page,+ (+ r"try another method",+ r"use another method",+ r"different method",+ r"other (?:options|methods)",+ ),+ )+ if expanded:+ reporter("expand MFA methods")+ await asyncio.sleep(1)+ clicked = await click_visible_text(session.page, push_patterns)+ if not clicked:+ raise DemoError("Push approval is not available on the ChatGPT MFA page")+ reporter("select Push approval")+ await asyncio.sleep(1)+ await click_visible_text(+ session.page, (r"^continue$", r"send push", r"send notification")+ )+++async def submit_external_login_once(+ session: PlaywrightChatGPTSession,+ email: str,+ password: str,+) -> None:+ state = await session.navigate_to_initial_login_state()+ if state.get("loggedIn"):+ return+ state = await session.navigate_to_login_form()+ if state.get("blockingReason"):+ raise DemoError(+ f"login blocked before credentials: {state.get('blockingReason')}"+ )+ if state.get("hasEmailInput"):+ session.report("fill email in authentication Chromium")+ await session.accept_cookie_consent()+ await session.fill_email_native(email)+ state = await session.wait_for_state_after_email_submit(+ timeout=60, label="password form"+ )+ if state.get("loggedIn"):+ return+ if not state.get("hasPasswordInput"):+ raise DemoError(+ f"password input did not appear; blocking={state.get('blockingReason')!r}"+ )+ await session.wait_for_auth_password_runtime_ready(timeout=20)+ session.report("submit password once in authentication Chromium")+ await session.fill_password_native(password)+++async def wait_for_external_login(+ session: PlaywrightChatGPTSession,+ args: argparse.Namespace,+ reporter: Reporter,+) -> None:+ deadline = time.monotonic() + max(1.0, float(args.login_timeout))+ selected_push = False+ tried_email_verification = False+ reported_device_approval = False+ while time.monotonic() < deadline:+ try:+ state = await session.helper("loginState", timeout=15)+ except Exception: # noqa: BLE001 - navigation can invalidate the helper realm.+ await asyncio.sleep(0.5)+ continue+ if state.get("loggedIn"):+ reporter("authentication approved")+ return+ reason = state.get("blockingReason") or auth_blocking_reason_from_url(+ str(state.get("url") or "")+ )+ if reason == "mfa" and not selected_push:+ await select_push_mfa(session, reporter)+ selected_push = True+ await asyncio.sleep(1)+ continue+ if reason == "device-approval":+ if (+ bool(getattr(args, "try_email_verification", False))+ and not tried_email_verification+ ):+ tried_email_verification = True+ if await session.click_try_with_email_verification():+ await asyncio.sleep(1)+ continue+ if not reported_device_approval:+ reporter("approve the new login in the ChatGPT app")+ reported_device_approval = True+ await asyncio.sleep(1)+ continue+ if reason in {"email-verification", "verification-code"}:+ if not session.has_auth_code_source():+ raise DemoError(+ "ChatGPT requested an email code but no auth-code input "+ "is configured"+ )+ code = await session.read_auth_code()+ reporter("submit ChatGPT email verification code")+ await session.fill_auth_code_native(code)+ session._auth_code_cache = None+ await asyncio.sleep(1.5)+ continue+ if reason:+ raise DemoError(+ f"ChatGPT authentication reached an unsupported step: {reason}"+ )+ await asyncio.sleep(0.5)+ if reported_device_approval:+ raise DemoError("timed out waiting for ChatGPT device approval")+ raise DemoError("timed out waiting for ChatGPT authentication")+++async def export_auth_state(session: PlaywrightChatGPTSession) -> ChromiumAuthState:+ if session.page is None or session.context is None:+ raise DemoError("authentication Chromium page is unavailable")+ if not session.page.url.startswith("https://chatgpt.com/"):+ await session.page.goto(+ "https://chatgpt.com/", wait_until="domcontentloaded", timeout=120_000+ )+ await session.wait_for_document_settle(timeout=10)+ cookies = chromium_cookie_params(await session.context.cookies())+ local_storage = await session.page.evaluate("Object.entries(localStorage)")+ user_agent = await session.page.evaluate("navigator.userAgent")+ if not isinstance(local_storage, list) or not all(+ isinstance(entry, list)+ and len(entry) == 2+ and all(isinstance(value, str) for value in entry)+ for entry in local_storage+ ):+ raise DemoError("authentication Chromium returned invalid localStorage state")+ if not isinstance(user_agent, str) or not user_agent:+ raise DemoError("authentication Chromium returned an empty user agent")+ if not cookies:+ raise DemoError("authentication Chromium returned no ChatGPT cookies")+ return ChromiumAuthState(+ cookies=cookies, local_storage=local_storage, user_agent=user_agent+ )+++async def authenticate_in_external_chromium(+ args: argparse.Namespace,+ email: str,+ password: str,+ reporter: Reporter,+) -> ChromiumAuthState:+ from playwright.async_api import async_playwright++ profile: Path | None = None+ xvfb: subprocess.Popen[str] | None = None+ chromium: subprocess.Popen[bytes] | None = None+ session: PlaywrightChatGPTSession | None = None+ try:+ profile = Path(tempfile.mkdtemp(prefix="moli-chatgpt-auth-chromium."))+ profile.chmod(0o700)+ xvfb, display = start_xvfb()+ port = reserve_local_port()+ endpoint = f"http://127.0.0.1:{port}"+ command = [+ str(resolve_auth_chromium(args)),+ f"--remote-debugging-port={port}",+ "--remote-debugging-address=127.0.0.1",+ "--remote-allow-origins=*",+ f"--user-data-dir={profile}",+ "--no-first-run",+ "--no-default-browser-check",+ "--password-store=basic",+ "--window-size=1440,1000",+ ]+ proxy, no_proxy = auth_proxy_options(args)+ if proxy:+ command.append(f"--proxy-server={proxy}")+ if no_proxy:+ command.append(f"--proxy-bypass-list={no_proxy.replace(',', ';')}")+ if hasattr(os, "geteuid") and os.geteuid() == 0:+ command.append("--no-sandbox")+ command.append("about:blank")+ environment = os.environ.copy()+ environment["DISPLAY"] = display+ reporter("start authentication Chromium under Xvfb")+ chromium = subprocess.Popen( # noqa: ASYNC220, S603 - trusted binary; explicit process-group cleanup.+ command,+ env=environment,+ stdout=subprocess.DEVNULL,+ stderr=subprocess.DEVNULL,+ start_new_session=True,+ )+ websocket_url = await wait_for_chromium_cdp(+ endpoint, chromium, float(args.startup_timeout)+ )+ playwright = await async_playwright().start()+ auth_args = argparse.Namespace(**vars(args))+ auth_args.backend = "chromium"+ session = PlaywrightChatGPTSession(auth_args, reporter=reporter)+ session.playwright = playwright+ session.browser = await playwright.chromium.connect_over_cdp(websocket_url)+ session.context = session.browser.contexts[0]+ await session.finish_page_setup()+ if session.page is None:+ raise DemoError("authentication Chromium did not expose a page target")+ webdriver = await session.page.evaluate("navigator.webdriver")+ if webdriver:+ raise DemoError(+ "authentication Chromium unexpectedly exposes navigator.webdriver"+ )+ await submit_external_login_once(session, email, password)+ await wait_for_external_login(session, auth_args, reporter)+ state = await export_auth_state(session)+ reporter(f"captured ChatGPT session ({len(state.cookies)} cookies)")+ return state+ finally:+ if session is not None:+ await session.close()+ terminate_process_group(chromium)+ terminate_process_group(xvfb)+ remove_auth_profile(profile)+++async def import_auth_state(+ session: PlaywrightChatGPTSession,+ state: ChromiumAuthState,+) -> None:+ if session.page is None or session.context is None:+ raise DemoError("Moli page is unavailable for authentication import")+ cdp = await session.context.new_cdp_session(session.page)+ await cdp.send("Network.enable")+ await cdp.send("Network.setCookies", {"cookies": state.cookies})+ await session.page.goto(+ "https://chatgpt.com/", wait_until="domcontentloaded", timeout=180_000+ )+ await session.page.evaluate(+ """entries => {+ for (const [key, value] of entries) localStorage.setItem(key, value);+ }""",+ state.local_storage,+ )+ await session.page.reload(wait_until="domcontentloaded", timeout=180_000)+ await session.require_existing_session()+++async def create_authenticated_moli_session(+ args: argparse.Namespace,+ email: str,+ password: str,+ reporter: Reporter = print,+) -> PlaywrightChatGPTSession:+ profile_dir = str(getattr(args, "profile_dir", "") or "")+ if profile_dir:+ prepare_profile_dir(profile_dir)+ if not getattr(args, "user_agent", None):+ stored_user_agent = load_profile_user_agent(profile_dir)+ if stored_user_agent:+ args.user_agent = stored_user_agent++ existing = PlaywrightChatGPTSession(args, reporter=reporter)+ try:+ await existing.start()+ except BaseException:+ await existing.close()+ raise+ try:+ await existing.require_existing_session()+ except DemoError:+ await existing.close()+ reporter("Moli profile needs ChatGPT authentication")+ else:+ reporter("reuse logged-in Moli profile")+ return existing++ if not password:+ raise DemoError(+ "password is required because the Moli profile is not logged in"+ )++ state = await authenticate_in_external_chromium(args, email, password, reporter)+ if not getattr(args, "user_agent", None):+ args.user_agent = state.user_agent++ authenticated = PlaywrightChatGPTSession(args, reporter=reporter)+ try:+ await authenticated.start()+ await import_auth_state(authenticated, state)+ if profile_dir:+ save_profile_user_agent(profile_dir, state.user_agent)+ reporter("ChatGPT authentication imported into Moli")+ return authenticated+ except BaseException:+ await authenticated.close()+ raisediff --git a/moli-playground/chatgpt/chatgpt_cdp_tui.py b/moli-playground/chatgpt/chatgpt_cdp_tui.pyindex e433aa028..0a303278c 100644--- a/moli-playground/chatgpt/chatgpt_cdp_tui.py+++ b/moli-playground/chatgpt/chatgpt_cdp_tui.py@@ -73,6 +73,7 @@ class TextField:@dataclassclass TuiState:fields: dict[str, TextField]+ title: str = "Moli ChatGPT CDP TUI"focus: str = "email"logged_in: bool = Falsebusy: bool = False@@ -290,7 +291,7 @@ def draw(stdscr: Any, state: TuiState, colors: dict[str, int]) -> None:stdscr.refresh()return- safe_add(stdscr, 0, 2, "Moli ChatGPT CDP TUI", colors["title"])+ safe_add(stdscr, 0, 2, state.title, colors["title"])safe_add(stdscr, 1, 2, state.status[: width - 4], colors["dim"] if not state.busy else 0)safe_add(stdscr, 2, 0, "-" * (width - 1))@@ -388,7 +389,7 @@ def submit_current(state: TuiState, backend: Backend) -> None:state.status = "email is required"add_message(state, "error", state.status)return- if not password:+ if not password and bool(getattr(backend, "requires_password", True)):state.status = "password is required"add_message(state, "error", state.status)return@@ -424,7 +425,8 @@ def run_tui_with_backend(stdscr: Any, args: argparse.Namespace, backend_cls: Any"password": TextField("password", "Password", os.environ.get("CHATGPT_PASSWORD", ""), secret=True),"auth_code": TextField("auth_code", "Auth Code"),"prompt": TextField("prompt", "Prompt", args.prompt),- }+ },+ title=str(getattr(args, "tui_title", "Moli ChatGPT CDP TUI")),)backend = backend_cls(args, events)try:diff --git a/moli-playground/chatgpt/chatgpt_playwright_tui.py b/moli-playground/chatgpt/chatgpt_playwright_tui.pyindex 72ed58655..ce35440d5 100644--- a/moli-playground/chatgpt/chatgpt_playwright_tui.py+++ b/moli-playground/chatgpt/chatgpt_playwright_tui.py@@ -7,12 +7,15 @@ import cursesimport osimport queueimport threading-from typing import Any+from chatgpt_auth_bridge import (+ create_authenticated_moli_session,+ default_moli_chatgpt_profile_dir,+)from chatgpt_cdp_demo import (DEFAULT_ANSWER_TIMEOUT,- DEFAULT_MOLI_HTTP_TIMEOUT_MS,DEFAULT_LOGIN_TIMEOUT,+ DEFAULT_MOLI_HTTP_TIMEOUT_MS,DEFAULT_STARTUP_TIMEOUT,DEFAULT_URL,)@@ -20,12 +23,19 @@ from chatgpt_cdp_tui import UiEvent, error_text, run_tui_with_backendfrom chatgpt_playwright_core import PlaywrightChatGPTSessionTUI_LOGIN_TIMEOUT = max(300.0, DEFAULT_LOGIN_TIMEOUT)-TUI_TRY_EMAIL_VERIFICATION = True+TUI_TRY_EMAIL_VERIFICATION = Falseclass PlaywrightBackend:- def __init__(self, args: argparse.Namespace, events: "queue.Queue[UiEvent]") -> None:+ requires_password = False++ def __init__(+ self, args: argparse.Namespace, events: "queue.Queue[UiEvent]"+ ) -> None:self.args = args+ self.requires_password = not (+ args.backend == "moli" and args.auth_backend == "chromium-bridge"+ )self.events = eventsself.auth_codes: "queue.Queue[str]" = queue.Queue()self.loop = asyncio.new_event_loop()@@ -60,9 +70,24 @@ class PlaywrightBackend:async def _login(self, email: str, password: str) -> None:try:self.args.auth_code_provider = self.read_auth_code_from_tui- self.session = PlaywrightChatGPTSession(self.args, reporter=lambda message: self.emit("status", message))- await self.session.start()- await self.session.login(email, password)++ def reporter(message: str) -> None:+ self.emit("status", message)++ if (+ self.args.backend == "moli"+ and self.args.auth_backend == "chromium-bridge"+ ):+ self.session = await create_authenticated_moli_session(+ self.args,+ email,+ password,+ reporter=reporter,+ )+ else:+ self.session = PlaywrightChatGPTSession(self.args, reporter=reporter)+ await self.session.start()+ await self.session.login(email, password)self.emit("login_ok", "login ok")except Exception as error: # noqa: BLE001 - show operational failures in the TUI.await self._cleanup()@@ -102,18 +127,39 @@ class PlaywrightBackend:def build_parser() -> argparse.ArgumentParser:- parser = argparse.ArgumentParser(description="Interactive Playwright TUI for ChatGPT over Moli CDP.")- parser.add_argument("--backend", choices=("moli", "chromium"), default="moli", help="browser backend, default: moli")- parser.add_argument("--url", default=DEFAULT_URL, help=f"initial URL, default: {DEFAULT_URL}")- parser.add_argument("--email", default=os.environ.get("CHATGPT_EMAIL", ""), help="pre-fill email")+ parser = argparse.ArgumentParser(+ description="Interactive Playwright TUI for ChatGPT over Moli CDP."+ )+ parser.add_argument(+ "--backend",+ choices=("moli", "chromium"),+ default="moli",+ help="browser backend, default: moli",+ )+ parser.add_argument(+ "--auth-backend",+ choices=("chromium-bridge", "moli"),+ default="chromium-bridge",+ help="fresh-login backend when chatting through Moli, default: chromium-bridge",+ )+ parser.add_argument(+ "--url", default=DEFAULT_URL, help=f"initial URL, default: {DEFAULT_URL}"+ )+ parser.add_argument(+ "--email", default=os.environ.get("CHATGPT_EMAIL", ""), help="pre-fill email"+ )parser.add_argument("--prompt", default="", help="pre-fill the prompt input")- parser.add_argument("--auth-code", default=os.environ.get("CHATGPT_AUTH_CODE", ""), help="verification code for email auth fallback")+ parser.add_argument(+ "--auth-code",+ default=os.environ.get("CHATGPT_AUTH_CODE", ""),+ help="verification code for email auth fallback",+ )parser.add_argument("--try-email-verification",dest="try_email_verification",action="store_true",default=TUI_TRY_EMAIL_VERIFICATION,- help="click Try with email on device approval pages, default: enabled",+ help="click Try with email on device approval pages, default: disabled",)parser.add_argument("--no-try-email-verification",@@ -135,30 +181,66 @@ def build_parser() -> argparse.ArgumentParser:"--live-trace-output",help="append sanitized live-trace summaries as JSON Lines to this path",)- parser.add_argument("--moli-bin", help="path to the moli binary; alternatively set MOLI_BIN")- parser.add_argument("--chromium-bin", help="path to a Chromium/Chrome executable for --backend chromium")- parser.add_argument("--headful", action="store_true", help="run Chromium with a visible browser window")- parser.add_argument("--profile-dir", help="optional Moli profile dir for cookies/localStorage")+ parser.add_argument(+ "--moli-bin", help="path to the moli binary; alternatively set MOLI_BIN"+ )+ parser.add_argument(+ "--chromium-bin",+ help="path to a Chromium/Chrome executable for --backend chromium",+ )+ parser.add_argument(+ "--auth-chromium-bin",+ help="Chromium/Chrome executable used only for Moli login bootstrap",+ )+ parser.add_argument(+ "--headful",+ action="store_true",+ help="run Chromium with a visible browser window",+ )+ parser.add_argument(+ "--profile-dir",+ default=os.environ.get(+ "MOLI_CHATGPT_PROFILE_DIR", str(default_moli_chatgpt_profile_dir())+ ),+ help="persistent Moli login profile, default: $MOLI_CHATGPT_PROFILE_DIR or the user data directory",+ )parser.add_argument("--user-agent", help="optional user agent passed to moli serve")parser.add_argument("--http-proxy", help="optional proxy passed to moli serve")- parser.add_argument("--http-no-proxy", help="optional no-proxy list passed to moli serve")+ parser.add_argument(+ "--http-no-proxy", help="optional no-proxy list passed to moli serve"+ )parser.add_argument("--http-timeout",type=int,default=DEFAULT_MOLI_HTTP_TIMEOUT_MS,help=f"Moli request timeout in milliseconds, default: {DEFAULT_MOLI_HTTP_TIMEOUT_MS}",)- parser.add_argument("--http-max-concurrent", type=int, help="optional max active fetch transfers passed to moli serve")- parser.add_argument("--http-max-host-open", type=int, help="optional per-host fetch transfer cap passed to moli serve")- parser.add_argument("--startup-timeout", type=float, default=DEFAULT_STARTUP_TIMEOUT)+ parser.add_argument(+ "--http-max-concurrent",+ type=int,+ help="optional max active fetch transfers passed to moli serve",+ )+ parser.add_argument(+ "--http-max-host-open",+ type=int,+ help="optional per-host fetch transfer cap passed to moli serve",+ )+ parser.add_argument(+ "--startup-timeout", type=float, default=DEFAULT_STARTUP_TIMEOUT+ )parser.add_argument("--login-timeout", type=float, default=TUI_LOGIN_TIMEOUT)parser.add_argument("--answer-timeout", type=float, default=DEFAULT_ANSWER_TIMEOUT)- parser.add_argument("--debug-snapshot", action="store_true", help="accepted for parity with the raw-CDP TUI")+ parser.add_argument(+ "--debug-snapshot",+ action="store_true",+ help="accepted for parity with the raw-CDP TUI",+ )return parserdef main() -> int:args = build_parser().parse_args()+ args.tui_title = "Moli ChatGPT Playwright TUI"curses.wrapper(run_tui_with_backend, args, PlaywrightBackend)return 0diff --git a/moli-playground/chatgpt/test_chatgpt_auth_bridge.py b/moli-playground/chatgpt/test_chatgpt_auth_bridge.pynew file mode 100644index 000000000..089b15f72--- /dev/null+++ b/moli-playground/chatgpt/test_chatgpt_auth_bridge.py@@ -0,0 +1,121 @@+from __future__ import annotations++import os+import stat+import tempfile+import unittest+from pathlib import Path+from unittest import mock++from chatgpt_auth_bridge import (+ auth_proxy_options,+ chromium_cookie_params,+ default_moli_chatgpt_profile_dir,+ load_profile_user_agent,+ prepare_profile_dir,+ save_profile_user_agent,+)+from chatgpt_cdp_demo import CHATGPT_HELPER_JS+from chatgpt_playwright_tui import PlaywrightBackend, build_parser+++class ChatGPTAuthBridgeTests(unittest.TestCase):+ def test_default_profile_uses_xdg_data_home(self) -> None:+ with mock.patch.dict(+ os.environ, {"XDG_DATA_HOME": "/tmp/moli-xdg-data"}, clear=False+ ):+ self.assertEqual(+ default_moli_chatgpt_profile_dir(),+ Path("/tmp/moli-xdg-data/moli/chatgpt-profile"),+ )++ def test_profile_metadata_round_trips_with_private_permissions(self) -> None:+ with tempfile.TemporaryDirectory() as temporary:+ profile = Path(temporary) / "profile"+ prepared = prepare_profile_dir(profile)+ save_profile_user_agent(prepared, "Test Browser/1.0")++ self.assertEqual(load_profile_user_agent(prepared), "Test Browser/1.0")+ self.assertEqual(stat.S_IMODE(prepared.stat().st_mode), 0o700)+ self.assertEqual(+ stat.S_IMODE(+ (prepared / ".chatgpt-playground-auth.json").stat().st_mode+ ),+ 0o600,+ )++ def test_cookie_conversion_keeps_only_chatgpt_auth_domains(self) -> None:+ converted = chromium_cookie_params(+ [+ {+ "name": "session",+ "value": "secret",+ "domain": ".chatgpt.com",+ "path": "/",+ "expires": 12345.0,+ "httpOnly": True,+ "secure": True,+ "sameSite": "Lax",+ },+ {+ "name": "auth",+ "value": "secret-2",+ "domain": "auth.openai.com",+ "path": "/",+ "expires": -1,+ "httpOnly": True,+ "secure": True,+ "sameSite": "None",+ },+ {+ "name": "unrelated",+ "value": "ignored",+ "domain": "example.com",+ "path": "/",+ },+ ]+ )++ self.assertEqual([cookie["name"] for cookie in converted], ["session", "auth"])+ self.assertEqual(converted[0]["expires"], 12345.0)+ self.assertNotIn("expires", converted[1])++ def test_auth_chromium_inherits_proxy_environment(self) -> None:+ args = mock.Mock(http_proxy=None, http_no_proxy=None)+ with mock.patch.dict(+ os.environ,+ {+ "HTTPS_PROXY": "http://proxy.example:8080",+ "NO_PROXY": "localhost,127.0.0.1",+ },+ clear=True,+ ):+ self.assertEqual(+ auth_proxy_options(args),+ ("http://proxy.example:8080", "localhost,127.0.0.1"),+ )++ def test_helper_ignores_google_hidden_password_and_avoids_double_submit(+ self,+ ) -> None:+ self.assertIn("hiddenpassword", CHATGPT_HELPER_JS)+ self.assertIn("style?.display === 'none'", CHATGPT_HELPER_JS)+ self.assertIn(+ "return { ok: true, reactSubmit: true, clickedSubmit: false };",+ CHATGPT_HELPER_JS,+ )++ def test_playwright_tui_defaults_to_bridge_and_persistent_profile(self) -> None:+ with mock.patch.dict(+ os.environ, {"XDG_DATA_HOME": "/tmp/moli-tui-data"}, clear=False+ ):+ args = build_parser().parse_args([])++ self.assertEqual(args.auth_backend, "chromium-bridge")+ self.assertEqual(args.profile_dir, "/tmp/moli-tui-data/moli/chatgpt-profile")+ self.assertFalse(args.try_email_verification)+ self.assertFalse(PlaywrightBackend.requires_password)+++if __name__ == "__main__":+ unittest.main()