fix: address SDL review feedback

- Ask before running a pygame program on Acode's main page, where it can
  reach the app (Python there is not isolated like the worker); declining
  runs it in the worker without a display, with an option to not ask again
- Do not start a game that was stopped while the SDL runtime or its
  packages were still loading, including while sdl.js itself loads
- Detect real await expressions with ast instead of matching the word,
  and stop blocking loops that cannot pause (no JSPI) after a few frames
  with a clear error instead of freezing Acode
- dispose() on unmount restores window.fetch (or makes the wrapper a
  pass-through if another plugin wrapped it since) and removes the iframe

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: bajrangCoder

README.md

@@ -72,6 +72,7 @@ while running:
 pygame.quit()
 ```
 
+- The display runs your program on Acode's main page instead of the isolated worker, so it could access the app and its data. The plugin asks before doing this (you can choose not to be asked again); only allow it for code you trust.
 - Blocking loops like this need Android System WebView 137 or newer (JSPI support). On older WebViews, make the loop async with `await asyncio.sleep(0)` each frame.
 - Running again or closing the console stops the game.
 - If SDL cannot start, the program runs without a display and the console explains why.

changelog.md

@@ -8,7 +8,7 @@
 - Packages such as `numpy`, `pandas`, `matplotlib` and `micropip` are downloaded automatically when imported (internet needed on first use)
 - matplotlib plots are shown in the console, on `plt.show()` or automatically when the program ends. Plots are sized to the console and rendered sharp on high-density screens
 - Pillow's `Image.show()` displays images in the console
-- Experimental pygame support: games draw to a canvas in the console, including ordinary blocking game loops on WebViews with JSPI (Android System WebView 137+). If SDL cannot start, the program runs without a display and the reason is shown
+- Experimental pygame support: games draw to a canvas in the console, including ordinary blocking game loops on WebViews with JSPI (Android System WebView 137+). Asks before running on Acode's main page. If SDL cannot start, the program runs without a display and the reason is shown
 - Header button to toggle line wrap in the console (remembered between sessions)
 - Thin progress line under the console header while Python is loading or code is running
 

plugin.zip

@@ -2,6 +2,7 @@ import plugin from "../plugin.json";
 import style from "./style.css";
 
 const WRAP_KEY = `${plugin.id}.wrap`;
+const SDL_ALLOWED_KEY = `${plugin.id}.sdlAllowed`;
 // Material "wrap_text" icon (Apache-2.0); Acode's icon font has no wrap glyph
 const WRAP_ICON =
 	'<svg viewBox="0 0 24 24" width="1em" height="1em" fill="currentColor" aria-hidden="true"><path d="M4 19h6v-2H4v2zM20 5H4v2h16V5zm-3 6H4v2h13.25c1.1 0 2 .9 2 2s-.9 2-2 2H15v-2l-3 3 3 3v-2h2c2.21 0 4-1.79 4-4s-1.79-4-4-4z"/></svg>';
@@ -32,6 +33,9 @@ class Python {
 	/** number of code runs still waiting for the worker */
 	#running = 0;
 	#sdlPromise = null;
+	/** bumped by every run and when the console closes, to drop stale runs */
+	#runId = 0;
+	#sdlAllowed = false;
 
 	INITIALIZING = 1;
 	INITIALIZED = 2;
@@ -51,6 +55,7 @@ class Python {
 
 		const onhide = $page.onhide;
 		$page.onhide = () => {
+			this.#runId += 1;
 			window.acodePythonSdl?.stop();
 			this.#state = this.NOT_INTIALIZED;
 			this.#worker?.terminate();
@@ -86,7 +91,7 @@ class Python {
 		// thin progress line along the header while Python loads or code runs
 		this.$status = tag("div", { className: "py-progress" });
 		this.$page.header?.append(this.$status, this.$wrapBtn);
-		this.#setWrap(loadWrap());
+		this.#setWrap(loadFlag(WRAP_KEY));
 		this.$style = tag("style", { textContent: style });
 		this.$input = tag("div", {
 			className: "print input",
@@ -154,30 +159,65 @@ class Python {
 	}
 
 	async run() {
+		const runId = ++this.#runId;
 		window.acodePythonSdl?.stop();
 		this.#showPage();
 		this.#inputCount = 0;
 		this.#append(this.$input);
 		await this.#cacheFile.writeFile("");
 
 		const code = editorManager.editor.getValue();
-		if (PYGAME_IMPORT.test(code) && (await this.#runWithSdl(code))) return;
+		if (PYGAME_IMPORT.test(code)) {
+			if (!(await this.#allowSdl())) {
+				this.print("Running without the pygame display.", "info");
+			} else if (await this.#runWithSdl(code, runId)) {
+				return;
+			}
+			if (runId !== this.#runId) return;
+		}
 		await this.runCode(code);
 	}
 
+	/**
+	 * The pygame display runs Python on Acode's own page, where it can reach
+	 * the app and its data, unlike the isolated worker. Ask before doing that.
+	 */
+	async #allowSdl() {
+		if (this.#sdlAllowed || loadFlag(SDL_ALLOWED_KEY)) return true;
+
+		const confirm =
+			acode.require?.("confirm") ??
+			((title, message) =>
+				Promise.resolve(window.confirm(`${title}\n\n${message}`)));
+		const answer = await confirm(
+			"Show pygame display?",
+			"The experimental pygame display runs this program on Acode's main page, where it can access the app and its data. Only continue for code you trust. Cancel runs it without the display.",
+			false,
+			{ checkboxText: "Don't ask again", returnState: true },
+		);
+		// older Acode versions return a plain boolean
+		const confirmed = typeof answer === "object" ? answer?.confirmed : answer;
+		if (!confirmed) return false;
+		this.#sdlAllowed = true;
+		if (answer?.checked) saveFlag(SDL_ALLOWED_KEY, true);
+		return true;
+	}
+
 	/**
 	 * Runs a pygame program with the experimental SDL runtime.
 	 * @returns {Promise<boolean>} false if SDL is unavailable and the caller
 	 * should fall back to the worker
 	 */
-	async #runWithSdl(code) {
+	async #runWithSdl(code, runId) {
 		const $canvas = tag("canvas");
 		const $media = tag("div", { className: "py-media", children: [$canvas] });
 		this.#append($media, this.$input);
 		this.#running += 1;
 		this.#updateStatus();
 		try {
 			const sdl = await this.#loadSdl();
+			// another run started or the console closed while sdl.js loaded
+			if (runId !== this.#runId) return true;
 			const error = await sdl.run(code, {
 				baseUrl: this.baseUrl,
 				canvas: $canvas,
@@ -261,7 +301,7 @@ class Python {
 
 		this.$wrapBtn?.remove();
 		this.$status?.remove();
-		window.acodePythonSdl?.stop();
+		window.acodePythonSdl?.dispose?.();
 		this.#worker?.terminate();
 		editorManager.off("switch-file", this.checkRunnable.bind(this));
 		editorManager.off("rename-file", this.checkRunnable.bind(this));
@@ -285,7 +325,7 @@ class Python {
 	/** Wraps long output lines instead of scrolling them horizontally */
 	#setWrap(wrap) {
 		this.$page.classList.toggle("wrap", wrap);
-		saveWrap(wrap);
+		saveFlag(WRAP_KEY, wrap);
 	}
 
 	print(res, type) {
@@ -494,19 +534,19 @@ class Python {
 	}
 }
 
-function loadWrap() {
+function loadFlag(key) {
 	try {
-		return localStorage.getItem(WRAP_KEY) === "true";
+		return localStorage.getItem(key) === "true";
 	} catch {
 		return false;
 	}
 }
 
-function saveWrap(wrap) {
+function saveFlag(key, value) {
 	try {
-		localStorage.setItem(WRAP_KEY, String(wrap));
+		localStorage.setItem(key, String(value));
 	} catch {
-		// the preference is a convenience, ignore storage failures
+		// preferences are a convenience, ignore storage failures
 	}
 }
 

src/main.js

@@ -17,14 +17,32 @@
 _installed = False
 _stop_requested = False
 
+# Without JSPI these calls cannot pause. An async game loop still lets the
+# event loop run between frames; a blocking one never does and would freeze
+# Acode, so it is stopped after a few frames without an event loop turn.
+MAX_PAUSES_WITHOUT_TURN = 10
+_waiting_for_turn = False
+_pauses_without_turn = 0
+
 
 class StopProgram(BaseException):
     """Raised inside the game loop when the console stops the program."""
 
 
+class BlockingLoopError(RuntimeError):
+    pass
+
+
 def reset():
     global _stop_requested
     _stop_requested = False
+    _event_loop_turned()
+
+
+def _event_loop_turned():
+    global _waiting_for_turn, _pauses_without_turn
+    _waiting_for_turn = False
+    _pauses_without_turn = 0
 
 
 def request_stop():
@@ -37,10 +55,26 @@ def _pause(seconds=0):
         raise StopProgram
     if can_run_sync():
         run_sync(asyncio.sleep(seconds))
+    else:
+        _check_not_blocking()
     if _stop_requested:
         raise StopProgram
 
 
+def _check_not_blocking():
+    global _waiting_for_turn, _pauses_without_turn
+    if not _waiting_for_turn:
+        _waiting_for_turn = True
+        asyncio.get_event_loop().call_soon(_event_loop_turned)
+        return
+    _pauses_without_turn += 1
+    if _pauses_without_turn >= MAX_PAUSES_WITHOUT_TURN:
+        raise BlockingLoopError(
+            "This WebView cannot pause Python (no JSPI support), so the game "
+            "loop must be async: add `await asyncio.sleep(0)` each frame."
+        )
+
+
 def install():
     global _installed
     if _installed:

src/python/acode_pygame.py

@@ -2,6 +2,7 @@
 // SDL needs a real <canvas>, which a worker does not have, so this runtime
 // runs on the main thread. Ordinary blocking game loops work through JSPI
 // (see python/acode_pygame.py); without JSPI only async loops are safe.
+// Code here can reach Acode's page, so main.js asks the user first.
 import {
 	flushFigures,
 	loadRuntime,
@@ -19,6 +20,18 @@ def start(code):
     acode_pygame.install()
     return asyncio.ensure_future(eval_code_async(code, {"__name__": "__main__"}))
 
+def has_await(code):
+    # real await expressions only, not the word in comments or strings
+    import ast
+    try:
+        tree = ast.parse(code)
+    except SyntaxError:
+        return False
+    return any(
+        isinstance(node, (ast.Await, ast.AsyncFor, ast.AsyncWith))
+        for node in ast.walk(tree)
+    )
+
 async def can_block():
     # only meaningful inside a task, where blocking code would run
     from pyodide.ffi import can_run_sync
@@ -52,7 +65,8 @@ let runner = null;
 /** the current run: its task handle and whether it was stopped */
 let current = null;
 let onFatal = () => {};
-let fetchRouted = false;
+/** set while window.fetch is routed, so dispose() can undo it */
+let fetchRoute = null;
 
 /**
  * Other plugins may replace `window.fetch` on Acode's page, e.g. with native
@@ -63,8 +77,7 @@ let fetchRouted = false;
  * taken from a hidden same-origin iframe; everything else is untouched.
  */
 function routeRuntimeFetch(baseUrl) {
-	if (fetchRouted) return;
-	fetchRouted = true;
+	if (fetchRoute) return;
 	const $frame = document.createElement("iframe");
 	$frame.style.display = "none";
 	$frame.setAttribute("aria-hidden", "true");
@@ -74,13 +87,27 @@ function routeRuntimeFetch(baseUrl) {
 	const pageFetch = window.fetch;
 	const prefixes = [baseUrl, PACKAGE_BASE_URL];
 
-	window.fetch = function (input, init) {
+	const route = { $frame, pageFetch, disposed: false, fetch: null };
+	route.fetch = function (input, init) {
 		const url = typeof input === "string" ? input : (input?.url ?? `${input}`);
-		if (prefixes.some((prefix) => url.startsWith(prefix))) {
+		if (!route.disposed && prefixes.some((prefix) => url.startsWith(prefix))) {
 			return browserFetch(input, init);
 		}
 		return pageFetch.call(this, input, init);
 	};
+	window.fetch = route.fetch;
+	fetchRoute = route;
+}
+
+/** Undoes routeRuntimeFetch when the plugin is unmounted */
+function unrouteRuntimeFetch() {
+	if (!fetchRoute) return;
+	// if another plugin wrapped fetch after us, restoring would drop their
+	// wrapper, so leave ours in place as a plain pass-through instead
+	if (window.fetch === fetchRoute.fetch) window.fetch = fetchRoute.pageFetch;
+	fetchRoute.disposed = true;
+	fetchRoute.$frame.remove();
+	fetchRoute = null;
 }
 
 function getRuntime(baseUrl) {
@@ -112,6 +139,7 @@ function getRuntime(baseUrl) {
 		pyodide.runPython(RUNNER_SOURCE, { globals: namespace });
 		runner = {
 			start: namespace.get("start"),
+			hasAwait: namespace.get("has_await"),
 			canBlock: namespace.get("can_block"),
 			stop: namespace.get("stop"),
 		};
@@ -143,18 +171,22 @@ async function run(
 	let pyodide;
 	try {
 		pyodide = await getRuntime(baseUrl);
+		// stopped while the runtime was loading
+		if (run.stopped) return null;
 		canvas.id = "canvas";
 		canvas.tabIndex = 0;
 		pyodide.canvas.setCanvas2D(canvas);
 		pyodide.runPython("import pygame\npygame.display.init()");
 		// a blocking game loop needs JSPI to pause, or it freezes Acode
-		if (!/\bawait\b/.test(code) && !(await runner.canBlock())) {
+		if (!runner.hasAwait(code) && !(await runner.canBlock())) {
 			throw new Error(
 				"this WebView cannot pause Python (no JSPI support), so the game loop must be async: await asyncio.sleep(0) each frame",
 			);
 		}
+		if (run.stopped) return null;
 	} catch (error) {
 		if (current === run) current = null;
+		if (run.stopped) return null;
 		throw new SdlUnavailableError(error?.message ?? String(error));
 	}
 
@@ -169,6 +201,8 @@ async function run(
 			width,
 			pixelRatio,
 		});
+		// stopped while packages were loading
+		if (run.stopped) return null;
 		const task = runner.start(code);
 		// awaiting a proxy of a Python awaitable consumes and destroys it,
 		// so keep a separate copy for stop() to cancel the task with
@@ -207,4 +241,12 @@ function stop() {
 	}
 }
 
-self.acodePythonSdl = { run, stop, SdlUnavailableError };
+/** Stops any program and undoes page changes when the plugin is unmounted */
+function dispose() {
+	stop();
+	unrouteRuntimeFetch();
+	if (self.acodePythonSdl === api) delete self.acodePythonSdl;
+}
+
+const api = { run, stop, dispose, SdlUnavailableError };
+self.acodePythonSdl = api;