Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.
Python agentaichatgptdeepseekfine-tuninggemmaimage-generationllamallmllmsopenaipythonqwenreinforcement-learningself-hostedstable-diffusiontext-to-speechttsuiunsloth
Stop the Chat UI persisted-monitor reset from running script in the stale page (#12412)
Daniel Hand2528e6796bb
diff --git a/tests/studio/playwright_chat_ui.py b/tests/studio/playwright_chat_ui.pyindex 987af7c1014..4bbc72ad893 100644--- a/tests/studio/playwright_chat_ui.py+++ b/tests/studio/playwright_chat_ui.py@@ -2462,32 +2462,44 @@ with sync_playwright() as p:step("persisted monitor: reset the browser session and open a fresh page")# Start fresh after the CLI rotation invalidates this browser session.# Stay in the SAME context: it keeps the init script and costs nothing to reuse.+ #+ # Nothing here runs script in the OLD page. It is CPU-throttled and its auth was+ # just revoked, so the app can be busy retrying, and page.evaluate waits for its+ # event loop with no timeout of its own: this step wedged for its whole budget on+ # Windows and on the Kaggle T4 runner with no line printed. Closing a page and+ # clearing cookies are browser-side calls, and the storage writes go through the+ # fresh page parked on a same-origin JSON endpoint where no app code runs. Each call+ # announces itself first, so a wedge that remains names the call it sits in.+ info("closing the stale page")try:- ctx.clear_cookies()+ page.close()except Exception as exc:- info(f"WARN clearing stale session cookies failed: {exc!r}")- robust_evaluate(- page,- """() => localStorage.setItem(- "unsloth_monitor_overlay",- JSON.stringify({ state: { isOpen: true, isMinimized: false }, version: 0 })- )""",- )+ info(f"WARN closing the stale page failed: {exc!r}")+ info("clearing stale session cookies")try:- page.evaluate(- "['unsloth_auth_token', 'unsloth_auth_refresh_token']"- ".forEach((key) => localStorage.removeItem(key))"- )+ ctx.clear_cookies()except Exception as exc:- info(f"WARN clearing stale auth tokens failed: {exc!r}")+ info(f"WARN clearing stale session cookies failed: {exc!r}")+ info("opening the fresh page")_fresh_page = new_throttled_page(ctx)_fresh_page.on("pageerror", lambda e: page_errors.append(str(e)))_fresh_page.on("console", _on_console)- try:- page.close()- except Exception:- passpage = _fresh_page+ info("parking the fresh page on /api/health to write localStorage")+ page.goto(f"{BASE}/api/health", wait_until = "domcontentloaded", timeout = 30_000)+ info("writing the monitor overlay and clearing the auth tokens")+ robust_evaluate(+ page,+ """() => {+ localStorage.setItem(+ "unsloth_monitor_overlay",+ JSON.stringify({ state: { isOpen: true, isMinimized: false }, version: 0 })+ );+ ["unsloth_auth_token", "unsloth_auth_refresh_token"].forEach(+ (key) => localStorage.removeItem(key)+ );+ }""",+ )login_system_request_count = len(system_requests)step("persisted monitor stays dormant on /login and resumes after auth", NO_STEP_CEILING)diff --git a/tests/studio/test_chat_ui_persisted_monitor_reset.py b/tests/studio/test_chat_ui_persisted_monitor_reset.pynew file mode 100644index 00000000000..b02233ca9b7--- /dev/null+++ b/tests/studio/test_chat_ui_persisted_monitor_reset.py@@ -0,0 +1,78 @@+# SPDX-License-Identifier: AGPL-3.0-only+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved.++"""The "persisted monitor: reset" step of playwright_chat_ui.py must not run script in+the page it is about to discard.++That page is CPU-throttled and its auth was revoked by the CLI rotation just before, so+the app can be busy retrying; page.evaluate waits for its event loop with no timeout of+its own. The step wedged for its whole watchdog budget on Windows and on the Kaggle T4+runner with nothing printed. The storage writes now go through the fresh page."""++import re+from pathlib import Path++DRIVER = Path(__file__).resolve().parent / "playwright_chat_ui.py"+CODE = DRIVER.read_text(encoding = "utf-8")+MARKER = 'step("persisted monitor: reset the browser session and open a fresh page")'+++def _step_body() -> str:+ start = CODE.index(MARKER)+ end = CODE.index("\n step(", start + len(MARKER))+ return CODE[start:end]+++def test_the_stale_page_runs_no_script_before_it_is_replaced():+ body = _step_body()+ handoff = body.index("page = _fresh_page")+ before = body[:handoff]+ assert not re.search(+ r"\bpage\.evaluate\(|robust_evaluate\(\s*page\b", before+ ), "the reset step evaluates in the stale page, which can wait on a busy event loop forever"+++def test_the_stale_page_is_closed_before_the_fresh_one_writes_storage():+ body = _step_body()+ assert body.index("page.close()") < body.index("new_throttled_page(ctx)"), (+ "close the stale page first, or its app can rewrite the shared localStorage "+ "after the fresh page has set it"+ )+ handoff = body.index("page = _fresh_page")+ writes = body.index("robust_evaluate(", handoff)+ assert "unsloth_monitor_overlay" in body[writes:]+ assert "unsloth_auth_refresh_token" in body[writes:]+++def test_the_fresh_page_writes_storage_where_no_app_code_runs():+ body = _step_body()+ goto = re.search(r'page\.goto\(f"\{BASE\}(?P<path>[^"]+)"', body)+ assert goto and goto.group("path").startswith("/api/"), (+ "park the fresh page on an API endpoint; any SPA route boots the app, which reads "+ "the auth tokens this step is clearing"+ )+ assert "timeout" in body[goto.start() : body.index(")", goto.end())]+++def test_every_blocking_call_announces_itself_first():+ body = _step_body()+ handoff = body.index("page = _fresh_page")+ calls = {+ "page.close()": body.index("page.close()"),+ "ctx.clear_cookies()": body.index("ctx.clear_cookies()"),+ "new_throttled_page(ctx)": body.index("new_throttled_page(ctx)"),+ "page.goto(": body.index("page.goto("),+ # The storage write is a timeout-free page.evaluate under the wrapper.+ "robust_evaluate(": body.index("robust_evaluate(", handoff),+ }+ for call, at in calls.items():+ # The statement directly before the call (a try: line in between is allowed),+ # not a nearby one: two calls in a row must each name themselves.+ preceding = [+ line.strip()+ for line in body[: body.rfind("\n", 0, at)].splitlines()+ if line.strip() and line.strip() != "try:"+ ]+ assert preceding and preceding[-1].startswith(+ "info("+ ), f"{call} has no breadcrumb directly before it, so a wedge there names the wrong call"