python-mister-fpga 0.1.0__tar.gz

python_mister_fpga-0.1.0/.github/workflows/tests.yml

@@ -0,0 +1,30 @@
+name: Tests
+
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.11", "3.12", "3.13"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: pip install -e ".[test]"
+
+      - name: Lint with ruff
+        run: ruff check .
+
+      - name: Run tests
+        run: pytest

python_mister_fpga-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+__pycache__/
+*.py[cod]
+.venv/
+dist/
+build/
+*.egg-info/
+.pytest_cache/
+.ruff_cache/
+.coverage
+.DS_Store

python_mister_fpga-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hudson Brendon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

python_mister_fpga-0.1.0/PKG-INFO

@@ -0,0 +1,122 @@
+Metadata-Version: 2.4
+Name: python-mister-fpga
+Version: 0.1.0
+Summary: Async Python client for the MiSTer FPGA mrext Remote API (REST + WebSocket) and SSH telemetry
+Project-URL: Homepage, https://github.com/hudsonbrendon/python-mister-fpga
+Project-URL: Issues, https://github.com/hudsonbrendon/python-mister-fpga/issues
+Author-email: Hudson Brendon <contato.hudsonbrendon@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: aiohttp,async,fpga,mister,mrext,retro
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: AsyncIO
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.11
+Requires-Dist: aiohttp>=3.9
+Requires-Dist: asyncssh>=2.21
+Provides-Extra: test
+Requires-Dist: aioresponses>=0.7; extra == 'test'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'test'
+Requires-Dist: pytest>=8; extra == 'test'
+Requires-Dist: ruff; extra == 'test'
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="assets/dark_logo.png" width="420">
+    <img src="assets/logo.png" alt="python-mister-fpga" width="420">
+  </picture>
+</p>
+
+# python-mister-fpga
+
+[![Tests](https://github.com/hudsonbrendon/python-mister-fpga/actions/workflows/tests.yml/badge.svg)](https://github.com/hudsonbrendon/python-mister-fpga/actions/workflows/tests.yml)
+[![PyPI version](https://img.shields.io/pypi/v/python-mister-fpga)](https://pypi.org/project/python-mister-fpga/)
+[![Python versions](https://img.shields.io/pypi/pyversions/python-mister-fpga)](https://pypi.org/project/python-mister-fpga/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+Async Python client for the [mrext Remote API](https://github.com/wizzomafizzo/mrext) (REST + WebSocket) and optional SSH telemetry for the MiSTer FPGA. Zero Home Assistant dependency — use it in any Python project.
+
+## Install
+
+```bash
+pip install python-mister-fpga
+```
+
+## Usage
+
+### REST client
+
+```python
+import asyncio
+from mister_fpga import MisterClient
+
+async def main():
+    client = MisterClient("192.168.1.50")
+    status = await client.async_get_status()
+    print(status.core, status.game)
+    await client.async_launch_game("/media/fat/games/SNES/Chrono.sfc")
+    await client.async_close()
+
+asyncio.run(main())
+```
+
+### WebSocket (real-time updates)
+
+```python
+import asyncio
+from mister_fpga import MisterWebSocketClient, MisterStatus, apply_ws_message
+
+state = MisterStatus(online=True)
+menu_path = None
+index_state = (False, False)
+
+def on_message(text: str) -> None:
+    global state, menu_path, index_state
+    state, menu_path, index_state = apply_ws_message(text, state, menu_path, index_state)
+    print(state.core, state.game)
+
+async def main():
+    ws = MisterWebSocketClient("192.168.1.50")
+    await ws.listen(on_message)
+
+asyncio.run(main())
+```
+
+### SSH telemetry
+
+```python
+import asyncio
+from mister_fpga import MisterSSH
+
+async def main():
+    ssh = MisterSSH("192.168.1.50", 22, "root", "1")
+    data = await ssh.async_probe()
+    print(data)
+    await ssh.async_close()
+
+asyncio.run(main())
+```
+
+## API
+
+- **`MisterClient(host, port=8182, *, session=None, timeout=10)`** — async REST client; call `await client.async_close()` when done, or inject your own `aiohttp.ClientSession`.
+- **`MisterStatus`** — dataclass snapshot: `online`, `core`, `system`, `game`, `hostname`, `version`, `ip`, `ips`, `dns`, `disk_total/used/free`. Property `is_running_game`.
+- **`MisterConnectionError`** — raised on network/HTTP errors.
+- **`MisterWebSocketClient(host, port=8182, *, session=None, reconnect_delay=5)`** — reconnecting WS loop; `await ws.listen(callback)`, call `ws.stop()` to exit.
+- **`apply_ws_message(message, status, menu_path, index_state)`** — pure reducer; apply a single WS text frame and return updated `(status, menu_path, index_state)`.
+- **`MisterSSH(host, port, username, password)`** — persistent asyncssh connection; `await ssh.async_probe()` returns telemetry dict.
+- **`parse_ssh_probe(raw)`** — parse the raw batched SSH output into a telemetry dict.
+- **`KEYBOARD_NAMES`**, **`INI_VIDEO_KEYS`**, **`WS_PATH`**, **`DEFAULT_PORT`** — protocol constants.
+
+## Credits
+
+REST/WebSocket API by [wizzomafizzo/mrext](https://github.com/wizzomafizzo/mrext). MiSTer-kun logo by the MiSTer-devel project. Author [@hudsonbrendon](https://github.com/hudsonbrendon).
+
+## License
+
+MIT — see [LICENSE](LICENSE).

python_mister_fpga-0.1.0/README.md

@@ -0,0 +1,95 @@
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="assets/dark_logo.png" width="420">
+    <img src="assets/logo.png" alt="python-mister-fpga" width="420">
+  </picture>
+</p>
+
+# python-mister-fpga
+
+[![Tests](https://github.com/hudsonbrendon/python-mister-fpga/actions/workflows/tests.yml/badge.svg)](https://github.com/hudsonbrendon/python-mister-fpga/actions/workflows/tests.yml)
+[![PyPI version](https://img.shields.io/pypi/v/python-mister-fpga)](https://pypi.org/project/python-mister-fpga/)
+[![Python versions](https://img.shields.io/pypi/pyversions/python-mister-fpga)](https://pypi.org/project/python-mister-fpga/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+Async Python client for the [mrext Remote API](https://github.com/wizzomafizzo/mrext) (REST + WebSocket) and optional SSH telemetry for the MiSTer FPGA. Zero Home Assistant dependency — use it in any Python project.
+
+## Install
+
+```bash
+pip install python-mister-fpga
+```
+
+## Usage
+
+### REST client
+
+```python
+import asyncio
+from mister_fpga import MisterClient
+
+async def main():
+    client = MisterClient("192.168.1.50")
+    status = await client.async_get_status()
+    print(status.core, status.game)
+    await client.async_launch_game("/media/fat/games/SNES/Chrono.sfc")
+    await client.async_close()
+
+asyncio.run(main())
+```
+
+### WebSocket (real-time updates)
+
+```python
+import asyncio
+from mister_fpga import MisterWebSocketClient, MisterStatus, apply_ws_message
+
+state = MisterStatus(online=True)
+menu_path = None
+index_state = (False, False)
+
+def on_message(text: str) -> None:
+    global state, menu_path, index_state
+    state, menu_path, index_state = apply_ws_message(text, state, menu_path, index_state)
+    print(state.core, state.game)
+
+async def main():
+    ws = MisterWebSocketClient("192.168.1.50")
+    await ws.listen(on_message)
+
+asyncio.run(main())
+```
+
+### SSH telemetry
+
+```python
+import asyncio
+from mister_fpga import MisterSSH
+
+async def main():
+    ssh = MisterSSH("192.168.1.50", 22, "root", "1")
+    data = await ssh.async_probe()
+    print(data)
+    await ssh.async_close()
+
+asyncio.run(main())
+```
+
+## API
+
+- **`MisterClient(host, port=8182, *, session=None, timeout=10)`** — async REST client; call `await client.async_close()` when done, or inject your own `aiohttp.ClientSession`.
+- **`MisterStatus`** — dataclass snapshot: `online`, `core`, `system`, `game`, `hostname`, `version`, `ip`, `ips`, `dns`, `disk_total/used/free`. Property `is_running_game`.
+- **`MisterConnectionError`** — raised on network/HTTP errors.
+- **`MisterWebSocketClient(host, port=8182, *, session=None, reconnect_delay=5)`** — reconnecting WS loop; `await ws.listen(callback)`, call `ws.stop()` to exit.
+- **`apply_ws_message(message, status, menu_path, index_state)`** — pure reducer; apply a single WS text frame and return updated `(status, menu_path, index_state)`.
+- **`MisterSSH(host, port, username, password)`** — persistent asyncssh connection; `await ssh.async_probe()` returns telemetry dict.
+- **`parse_ssh_probe(raw)`** — parse the raw batched SSH output into a telemetry dict.
+- **`KEYBOARD_NAMES`**, **`INI_VIDEO_KEYS`**, **`WS_PATH`**, **`DEFAULT_PORT`** — protocol constants.
+
+## Credits
+
+REST/WebSocket API by [wizzomafizzo/mrext](https://github.com/wizzomafizzo/mrext). MiSTer-kun logo by the MiSTer-devel project. Author [@hudsonbrendon](https://github.com/hudsonbrendon).
+
+## License
+
+MIT — see [LICENSE](LICENSE).

python_mister_fpga-0.1.0/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "python-mister-fpga"
+version = "0.1.0"
+description = "Async Python client for the MiSTer FPGA mrext Remote API (REST + WebSocket) and SSH telemetry"
+readme = "README.md"
+requires-python = ">=3.11"
+license = {text = "MIT"}
+authors = [{name = "Hudson Brendon", email = "contato.hudsonbrendon@gmail.com"}]
+keywords = ["mister", "fpga", "mrext", "retro", "async", "aiohttp"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Framework :: AsyncIO",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Software Development :: Libraries",
+]
+dependencies = ["aiohttp>=3.9", "asyncssh>=2.21"]
+
+[project.urls]
+Homepage = "https://github.com/hudsonbrendon/python-mister-fpga"
+Issues = "https://github.com/hudsonbrendon/python-mister-fpga/issues"
+
+[project.optional-dependencies]
+test = ["pytest>=8", "pytest-asyncio>=0.23", "aioresponses>=0.7", "ruff"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/mister_fpga"]
+
+[tool.ruff]
+target-version = "py311"
+line-length = 88
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+addopts = "-q"

python_mister_fpga-0.1.0/src/mister_fpga/__init__.py

@@ -0,0 +1,20 @@
+"""Async Python client for the MiSTer FPGA mrext Remote API."""
+from .client import MisterClient, MisterConnectionError, MisterStatus
+from .const import DEFAULT_PORT, INI_VIDEO_KEYS, KEYBOARD_NAMES, WS_PATH
+from .ssh import MisterSSH, parse_ssh_probe
+from .websocket import MisterWebSocketClient, apply_ws_message
+
+__all__ = [
+    "MisterClient",
+    "MisterStatus",
+    "MisterConnectionError",
+    "MisterWebSocketClient",
+    "apply_ws_message",
+    "MisterSSH",
+    "parse_ssh_probe",
+    "KEYBOARD_NAMES",
+    "INI_VIDEO_KEYS",
+    "WS_PATH",
+    "DEFAULT_PORT",
+]
+__version__ = "0.1.0"

python_mister_fpga-0.1.0/src/mister_fpga/client.py

@@ -0,0 +1,292 @@
+"""Async REST client for the MiSTer FPGA mrext Remote API."""
+from __future__ import annotations
+
+import json
+import logging
+from dataclasses import dataclass, field
+from typing import Any
+
+import aiohttp
+
+from .const import (
+    PATH_CORE_MENU,
+    PATH_GAMES_INDEX,
+    PATH_GAMES_LAUNCH,
+    PATH_GAMES_SEARCH,
+    PATH_INIS,
+    PATH_KEYBOARD,
+    PATH_KEYBOARD_RAW,
+    PATH_LAUNCH,
+    PATH_LAUNCH_MENU,
+    PATH_LAUNCH_NEW,
+    PATH_LAUNCH_TOKEN,
+    PATH_MUSIC_NEXT,
+    PATH_MUSIC_PLAY,
+    PATH_MUSIC_PLAYBACK,
+    PATH_MUSIC_PLAYLIST,
+    PATH_MUSIC_STATUS,
+    PATH_MUSIC_STOP,
+    PATH_PEERS,
+    PATH_PLAYING,
+    PATH_REBOOT,
+    PATH_RESTART_REMOTE,
+    PATH_SCREENSHOTS,
+    PATH_SCRIPTS_CONSOLE,
+    PATH_SCRIPTS_KILL,
+    PATH_SCRIPTS_LAUNCH,
+    PATH_SCRIPTS_LIST,
+    PATH_SYSINFO,
+    PATH_SYSTEMS,
+    PATH_WALLPAPERS,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class MisterConnectionError(Exception):
+    """Raised when the MiSTer Remote API is unreachable or returns an error."""
+
+
+@dataclass
+class MisterStatus:
+    """Snapshot of the MiSTer device state."""
+
+    online: bool = False
+    core: str | None = None
+    system: str | None = None
+    system_name: str | None = None
+    game: str | None = None
+    game_name: str | None = None
+    hostname: str | None = None
+    version: str | None = None
+    ip: str | None = None
+    ips: list[str] = field(default_factory=list)
+    updated: str | None = None
+    dns: str | None = None
+    disk_total: int | None = None
+    disk_used: int | None = None
+    disk_free: int | None = None
+
+    @property
+    def is_running_game(self) -> bool:
+        """True when a real core/game (not the menu) is running."""
+        if not self.online:
+            return False
+        core = (self.core or "").strip().lower()
+        return bool(core) and core not in ("menu", "none")
+
+
+class MisterClient:
+    """Thin async wrapper around the mrext Remote REST API."""
+
+    def __init__(
+        self,
+        host: str,
+        port: int = 8182,
+        *,
+        session: aiohttp.ClientSession | None = None,
+        timeout: int = 10,
+    ) -> None:
+        self.host = host
+        self.port = port
+        self.base_url = f"http://{host}:{port}/api"
+        self._timeout = timeout
+        self._session = session
+        self._owns_session = session is None
+
+    async def _get_session(self) -> aiohttp.ClientSession:
+        if self._session is None:
+            self._session = aiohttp.ClientSession()
+        return self._session
+
+    async def async_close(self) -> None:
+        """Close the session only if this client created it."""
+        if self._owns_session and self._session is not None:
+            await self._session.close()
+            self._session = None
+
+    async def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        payload: dict | None = None,
+        parse_json: bool = True,
+    ) -> Any:
+        session = await self._get_session()
+        url = f"{self.base_url}{path}"
+        try:
+            async with session.request(
+                method,
+                url,
+                json=payload,
+                timeout=aiohttp.ClientTimeout(total=self._timeout),
+            ) as resp:
+                resp.raise_for_status()
+                if not parse_json:
+                    return await resp.read()
+                text = await resp.text()
+                if not text.strip():
+                    return None
+                try:
+                    return json.loads(text)
+                except json.JSONDecodeError as err:
+                    raise MisterConnectionError(
+                        f"{method} {url} returned invalid JSON: {err}"
+                    ) from err
+        except (TimeoutError, aiohttp.ClientError) as err:
+            _LOGGER.debug("Request %s %s failed: %s", method, url, err)
+            raise MisterConnectionError(f"{method} {url} failed: {err}") from err
+
+    async def async_get_status(self) -> MisterStatus:
+        sysinfo = await self._request("GET", PATH_SYSINFO) or {}
+        playing = await self._request("GET", PATH_PLAYING) or {}
+        ips = sysinfo.get("ips") or []
+        disks = sysinfo.get("disks") or []
+        disk = disks[0] if disks else {}
+        return MisterStatus(
+            online=True,
+            core=playing.get("core") or None,
+            system=playing.get("system") or None,
+            system_name=playing.get("systemName") or None,
+            game=playing.get("game") or None,
+            game_name=playing.get("gameName") or None,
+            hostname=sysinfo.get("hostname"),
+            version=sysinfo.get("version"),
+            ips=ips,
+            ip=ips[0] if ips else None,
+            updated=sysinfo.get("updated"),
+            dns=sysinfo.get("dns"),
+            disk_total=disk.get("total"),
+            disk_used=disk.get("used"),
+            disk_free=disk.get("free"),
+        )
+
+    async def async_get_systems(self) -> list[dict]:
+        return await self._request("GET", PATH_SYSTEMS) or []
+
+    async def async_launch_system(self, system_id: str) -> None:
+        await self._request("POST", f"{PATH_SYSTEMS}/{system_id}")
+
+    async def async_launch_game(self, path: str) -> None:
+        await self._request("POST", PATH_GAMES_LAUNCH, payload={"path": path})
+
+    async def async_launch_menu(self) -> None:
+        await self._request("POST", PATH_LAUNCH_MENU)
+
+    async def async_search_games(self, query: str, system: str = "all") -> dict:
+        return (
+            await self._request(
+                "POST", PATH_GAMES_SEARCH, payload={"data": query, "system": system}
+            )
+            or {}
+        )
+
+    async def async_index_games(self) -> None:
+        await self._request("POST", PATH_GAMES_INDEX)
+
+    async def async_send_keyboard(self, name: str) -> None:
+        await self._request("POST", f"{PATH_KEYBOARD}/{name}")
+
+    async def async_reboot(self) -> None:
+        await self._request("POST", PATH_REBOOT)
+
+    async def async_restart_remote(self) -> None:
+        await self._request("POST", PATH_RESTART_REMOTE)
+
+    async def async_take_screenshot(self) -> None:
+        await self._request("POST", PATH_SCREENSHOTS)
+
+    async def async_get_screenshots(self) -> list[dict]:
+        return await self._request("GET", PATH_SCREENSHOTS) or []
+
+    async def async_get_screenshot_image(self, core: str, filename: str) -> bytes:
+        return await self._request(
+            "GET", f"{PATH_SCREENSHOTS}/{core}/{filename}", parse_json=False
+        )
+
+    async def async_get_music_status(self) -> dict:
+        return await self._request("GET", PATH_MUSIC_STATUS) or {}
+
+    async def async_music_play(self) -> None:
+        await self._request("POST", PATH_MUSIC_PLAY)
+
+    async def async_music_stop(self) -> None:
+        await self._request("POST", PATH_MUSIC_STOP)
+
+    async def async_music_next(self) -> None:
+        await self._request("POST", PATH_MUSIC_NEXT)
+
+    # --- Wallpapers ---
+    async def async_get_wallpapers(self) -> dict:
+        return await self._request("GET", PATH_WALLPAPERS) or {}
+
+    async def async_set_wallpaper(self, filename: str) -> None:
+        await self._request("POST", f"{PATH_WALLPAPERS}/{filename}")
+
+    async def async_clear_wallpaper(self) -> None:
+        await self._request("DELETE", PATH_WALLPAPERS)
+
+    # --- INI files ---
+    async def async_get_inis(self) -> dict:
+        return await self._request("GET", PATH_INIS) or {}
+
+    async def async_get_ini_values(self, ini_id: int) -> dict:
+        return await self._request("GET", f"{PATH_INIS}/{ini_id}") or {}
+
+    async def async_set_active_ini(self, ini_id: int) -> None:
+        await self._request("PUT", PATH_INIS, payload={"ini": ini_id})
+
+    async def async_set_ini_values(self, ini_id: int, values: dict) -> None:
+        await self._request("PUT", f"{PATH_INIS}/{ini_id}", payload=values)
+
+    async def async_set_background_mode(self, mode: int) -> None:
+        await self._request("PUT", PATH_CORE_MENU, payload={"mode": mode})
+
+    # --- Music (extended) ---
+    async def async_get_music_playlists(self) -> list[str]:
+        return await self._request("GET", PATH_MUSIC_PLAYLIST) or []
+
+    async def async_set_music_playlist(self, name: str) -> None:
+        await self._request("POST", f"{PATH_MUSIC_PLAYLIST}/{name}")
+
+    async def async_set_music_playback(self, mode: str) -> None:
+        await self._request("POST", f"{PATH_MUSIC_PLAYBACK}/{mode}")
+
+    # --- Scripts ---
+    async def async_get_scripts(self) -> dict:
+        return await self._request("GET", PATH_SCRIPTS_LIST) or {}
+
+    async def async_launch_script(self, filename: str) -> None:
+        await self._request("POST", f"{PATH_SCRIPTS_LAUNCH}/{filename}")
+
+    async def async_open_console(self) -> None:
+        await self._request("POST", PATH_SCRIPTS_CONSOLE)
+
+    async def async_kill_script(self) -> None:
+        await self._request("POST", PATH_SCRIPTS_KILL)
+
+    # --- Peers ---
+    async def async_get_peers(self) -> list[dict]:
+        data = await self._request("GET", PATH_PEERS) or {}
+        return data.get("peers", [])
+
+    # --- Launchers ---
+    async def async_launch_path(self, path: str) -> None:
+        await self._request("POST", PATH_LAUNCH, payload={"path": path})
+
+    async def async_launch_token(self, data: str) -> None:
+        await self._request("GET", f"{PATH_LAUNCH_TOKEN}/{data}")
+
+    async def async_create_shortcut(
+        self, game_path: str, folder: str, name: str
+    ) -> dict:
+        return await self._request(
+            "POST",
+            PATH_LAUNCH_NEW,
+            payload={"gamePath": game_path, "folder": folder, "name": name},
+        ) or {}
+
+    # --- Raw keyboard ---
+    async def async_send_keyboard_raw(self, code: int) -> None:
+        await self._request("POST", f"{PATH_KEYBOARD_RAW}/{code}")

python_mister_fpga-0.1.0/src/mister_fpga/const.py

@@ -0,0 +1,62 @@
+"""Protocol constants for the MiSTer FPGA mrext Remote API."""
+from __future__ import annotations
+
+DEFAULT_PORT = 8182
+HTTP_TIMEOUT = 10
+
+# mrext Remote API paths (relative to base_url = http://host:port/api)
+PATH_PLAYING = "/games/playing"
+PATH_SYSINFO = "/sysinfo"
+PATH_SYSTEMS = "/systems"
+PATH_GAMES_LAUNCH = "/games/launch"
+PATH_GAMES_SEARCH = "/games/search"
+PATH_GAMES_INDEX = "/games/index"
+PATH_LAUNCH_MENU = "/launch/menu"
+PATH_KEYBOARD = "/controls/keyboard"
+PATH_REBOOT = "/settings/system/reboot"
+PATH_RESTART_REMOTE = "/settings/remote/restart"
+PATH_SCREENSHOTS = "/screenshots"
+PATH_MUSIC_STATUS = "/music/status"
+PATH_MUSIC_PLAY = "/music/play"
+PATH_MUSIC_STOP = "/music/stop"
+PATH_MUSIC_NEXT = "/music/next"
+PATH_MUSIC_PLAYLIST = "/music/playlist"
+PATH_MUSIC_PLAYBACK = "/music/playback"
+PATH_WALLPAPERS = "/wallpapers"
+PATH_INIS = "/settings/inis"
+PATH_CORE_MENU = "/settings/core/menu"
+PATH_SCRIPTS_LIST = "/scripts/list"
+PATH_SCRIPTS_LAUNCH = "/scripts/launch"
+PATH_SCRIPTS_CONSOLE = "/scripts/console"
+PATH_SCRIPTS_KILL = "/scripts/kill"
+PATH_PEERS = "/settings/remote/peers"
+PATH_LAUNCH = "/launch"
+PATH_LAUNCH_TOKEN = "/l"
+PATH_LAUNCH_NEW = "/launch/new"
+PATH_KEYBOARD_RAW = "/controls/keyboard-raw"
+
+# WebSocket endpoint (mounted under /api on Remote v0.4)
+WS_PATH = "/api/ws"
+
+# MiSTer.ini keys exposed as Number entities (value range 0-100)
+INI_VIDEO_KEYS = ("video_brightness", "video_contrast", "video_saturation")
+
+# SSH defaults and probe command
+DEFAULT_SSH_PORT = 22
+DEFAULT_SSH_USERNAME = "root"
+
+SSH_PROBE_CMD = (
+    "cat /tmp/CORENAME 2>/dev/null; echo '|||'; "
+    "cat /proc/uptime 2>/dev/null; echo '|||'; "
+    "cat /proc/loadavg 2>/dev/null; echo '|||'; "
+    "awk '/MemTotal|MemAvailable/{print $2}' /proc/meminfo 2>/dev/null; echo '|||'; "
+    "stat -c %Y /media/fat/MiSTer 2>/dev/null"
+)
+
+# Keyboard control names accepted by POST /controls/keyboard/{name}
+KEYBOARD_NAMES = (
+    "up", "down", "left", "right", "confirm", "back", "cancel", "menu",
+    "osd", "core_select", "user", "volume_up", "volume_down", "volume_mute",
+    "reset", "screenshot", "raw_screenshot", "console", "exit_console",
+    "computer_osd", "change_background", "pair_bluetooth", "toggle_core_dates",
+)

python_mister_fpga-0.1.0/src/mister_fpga/ssh.py

@@ -0,0 +1,88 @@
+"""Optional SSH telemetry client for the MiSTer FPGA."""
+from __future__ import annotations
+
+import logging
+
+from .const import SSH_PROBE_CMD
+
+_LOGGER = logging.getLogger(__name__)
+
+_SEP = "|||"
+
+
+def parse_ssh_probe(raw: str) -> dict:
+    """Parse the batched SSH probe output into a telemetry dict. Tolerant of blanks."""
+    parts = [p.strip() for p in raw.split(_SEP)]
+    while len(parts) < 5:
+        parts.append("")
+    core, uptime_s, load_s, mem_s, fw_s = parts[:5]
+
+    def _int(value: str) -> int | None:
+        try:
+            return int(float(value))
+        except (TypeError, ValueError):
+            return None
+
+    uptime = _int(uptime_s.split()[0]) if uptime_s else None
+    load_1m = None
+    if load_s:
+        try:
+            load_1m = float(load_s.split()[0])
+        except (ValueError, IndexError):
+            load_1m = None
+    mem_used_pct = None
+    mem_lines = [m for m in mem_s.splitlines() if m]
+    if len(mem_lines) >= 2:
+        total = _int(mem_lines[0])
+        avail = _int(mem_lines[1])
+        if total:
+            mem_used_pct = round((total - avail) / total * 100, 1)
+    fw_ts = _int(fw_s) if fw_s else None
+
+    return {
+        "active_core": core or None,
+        "uptime_seconds": uptime,
+        "cpu_load_1m": load_1m,
+        "memory_used_percent": mem_used_pct,
+        "firmware_timestamp": fw_ts,
+    }
+
+
+class MisterSSH:
+    """Maintains a persistent asyncssh connection and runs the probe."""
+
+    def __init__(self, host: str, port: int, username: str, password: str) -> None:
+        self.host = host
+        self.port = port
+        self.username = username
+        self.password = password
+        self._conn = None
+
+    async def _ensure(self) -> None:
+        if self._conn is not None:
+            return
+        import asyncssh
+
+        self._conn = await asyncssh.connect(
+            self.host,
+            port=self.port,
+            username=self.username,
+            password=self.password,
+            known_hosts=None,
+        )
+
+    async def async_probe(self) -> dict:
+        """Run the probe; returns {} on any failure (SSH is best-effort)."""
+        try:
+            await self._ensure()
+            result = await self._conn.run(SSH_PROBE_CMD, check=False, timeout=10)
+            return parse_ssh_probe(result.stdout or "")
+        except Exception as err:  # noqa: BLE001 - asyncssh raises many types; SSH is best-effort and must never break the HTTP integration
+            _LOGGER.debug("MiSTer SSH probe failed: %s", err)
+            self._conn = None
+            return {}
+
+    async def async_close(self) -> None:
+        if self._conn is not None:
+            self._conn.close()
+            self._conn = None

python_mister_fpga-0.1.0/src/mister_fpga/websocket.py

@@ -0,0 +1,103 @@
+"""WebSocket client for real-time MiSTer Remote updates."""
+from __future__ import annotations
+
+import asyncio
+import logging
+from dataclasses import replace
+
+import aiohttp
+
+from .client import MisterStatus
+from .const import WS_PATH
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def apply_ws_message(
+    message: str,
+    status: MisterStatus,
+    menu_path: str | None,
+    index_state: tuple[bool, bool],
+) -> tuple[MisterStatus, str | None, tuple[bool, bool]]:
+    """Pure reducer: apply one WS text frame to (status, menu_path, index_state)."""
+    prefix, _, rest = message.partition(":")
+    if prefix == "coreRunning":
+        core = rest.strip() or None
+        if core is None:
+            return (
+                replace(status, core=None, game=None, game_name=None),
+                menu_path,
+                index_state,
+            )
+        return replace(status, core=core), menu_path, index_state
+    if prefix == "gameRunning":
+        rest = rest.strip()
+        if not rest:
+            return replace(status, game=None, game_name=None), menu_path, index_state
+        _, _, name = rest.partition("/")
+        game_name = name.rsplit(".", 1)[0] if name else None
+        return replace(status, game=rest, game_name=game_name), menu_path, index_state
+    if prefix == "menuNavigation":
+        return status, rest.strip() or None, index_state
+    if prefix == "indexStatus":
+        parts = rest.split(",")
+        exists = len(parts) > 0 and parts[0] == "y"
+        in_progress = len(parts) > 1 and parts[1] == "y"
+        return status, menu_path, (exists, in_progress)
+    return status, menu_path, index_state
+
+
+class MisterWebSocketClient:
+    """Connects to the mrext Remote WebSocket and invokes a callback per text frame."""
+
+    def __init__(
+        self,
+        host: str,
+        port: int = 8182,
+        *,
+        session=None,
+        reconnect_delay: int = 5,
+    ) -> None:
+        self.host = host
+        self.port = port
+        self._session = session
+        self._owns_session = session is None
+        self._reconnect_delay = reconnect_delay
+        self._stop = False
+
+    @property
+    def url(self) -> str:
+        return f"ws://{self.host}:{self.port}{WS_PATH}"
+
+    async def listen(self, on_message) -> None:
+        """Run the reconnect loop, calling on_message(text) for each TEXT frame.
+
+        on_message may be sync or async. Runs until stop() or cancellation.
+        """
+        owns = self._session is None
+        session = self._session or aiohttp.ClientSession()
+        try:
+            while not self._stop:
+                try:
+                    async with session.ws_connect(self.url, heartbeat=30) as ws:
+                        async for msg in ws:
+                            if msg.type == aiohttp.WSMsgType.TEXT:
+                                result = on_message(msg.data)
+                                if hasattr(result, "__await__"):
+                                    await result
+                            elif msg.type in (
+                                aiohttp.WSMsgType.CLOSED,
+                                aiohttp.WSMsgType.ERROR,
+                            ):
+                                break
+                except (aiohttp.ClientError, TimeoutError):
+                    pass
+                if self._stop:
+                    break
+                await asyncio.sleep(self._reconnect_delay)
+        finally:
+            if owns:
+                await session.close()
+
+    def stop(self) -> None:
+        self._stop = True

python_mister_fpga-0.1.0/tests/test_client.py

@@ -0,0 +1,343 @@
+"""Tests for the MiSTer FPGA API client."""
+from __future__ import annotations
+
+import aiohttp
+import pytest
+from aiohttp import ClientSession
+from aioresponses import aioresponses
+
+from mister_fpga.client import (
+    MisterClient,
+    MisterConnectionError,
+    MisterStatus,
+)
+
+BASE = "http://192.168.31.77:8182/api"
+
+
+@pytest.fixture
+async def client():
+    """Return a MisterClient backed by a ClientSession with ThreadedResolver.
+
+    Using aiohttp.ThreadedResolver instead of the default AsyncResolver (aiodns)
+    prevents pycares from spawning its ``_run_safe_shutdown_loop`` daemon thread.
+    """
+    connector = aiohttp.TCPConnector(resolver=aiohttp.ThreadedResolver())
+    session = ClientSession(connector=connector)
+    try:
+        yield MisterClient("192.168.31.77", 8182, session=session)
+    finally:
+        await session.close()
+
+
+def test_base_url():
+    client = MisterClient("1.2.3.4", 8182)
+    assert client.base_url == "http://1.2.3.4:8182/api"
+
+
+def test_timeout_param():
+    c = MisterClient("h", timeout=30)
+    assert c._timeout == 30
+
+
+def test_status_is_running_game():
+    assert MisterStatus(online=True, core="SNES").is_running_game is True
+    assert MisterStatus(online=True, core="MENU").is_running_game is False
+    assert MisterStatus(online=True, core="").is_running_game is False
+    assert MisterStatus(online=False, core="SNES").is_running_game is False
+
+
+async def test_get_status_merges_endpoints(client):
+    with aioresponses() as m:
+        m.get(
+            f"{BASE}/sysinfo",
+            payload={
+                "ips": ["192.168.31.77"],
+                "hostname": "MiSTer",
+                "version": "240101",
+                "updated": "2026-05-30",
+                "dns": "MiSTer.local",
+                "disks": [
+                    {
+                        "path": "/media/fat",
+                        "total": 100,
+                        "used": 75,
+                        "free": 25,
+                        "displayName": "SD card",
+                    }
+                ],
+            },
+        )
+        m.get(
+            f"{BASE}/games/playing",
+            payload={
+                "core": "SNES",
+                "system": "SNES",
+                "systemName": "Super Nintendo",
+                "game": "/games/SNES/Chrono.sfc",
+                "gameName": "Chrono Trigger",
+            },
+        )
+        status = await client.async_get_status()
+    assert status.online is True
+    assert status.core == "SNES"
+    assert status.system_name == "Super Nintendo"
+    assert status.game_name == "Chrono Trigger"
+    assert status.version == "240101"
+    assert status.hostname == "MiSTer"
+    assert status.ip == "192.168.31.77"
+    assert status.dns == "MiSTer.local"
+    assert status.disk_total == 100
+    assert status.disk_used == 75
+    assert status.disk_free == 25
+
+
+async def test_get_status_raises_on_error(client):
+    with aioresponses() as m:
+        m.get(f"{BASE}/sysinfo", status=500)
+        with pytest.raises(MisterConnectionError):
+            await client.async_get_status()
+
+
+async def test_get_systems(client):
+    with aioresponses() as m:
+        m.get(
+            f"{BASE}/systems",
+            payload=[{"id": "SNES", "name": "Super Nintendo", "category": "Console"}],
+        )
+        systems = await client.async_get_systems()
+    assert systems[0]["id"] == "SNES"
+
+
+async def test_launch_game_posts_path(client):
+    with aioresponses() as m:
+        m.post(f"{BASE}/games/launch", status=200)
+        await client.async_launch_game("/games/SNES/Chrono.sfc")
+        import yarl
+
+        key = ("POST", yarl.URL(f"{BASE}/games/launch"))
+        assert m.requests[key][0].kwargs["json"] == {"path": "/games/SNES/Chrono.sfc"}
+
+
+async def test_launch_system(client):
+    with aioresponses() as m:
+        m.post(f"{BASE}/systems/SNES", status=200)
+        await client.async_launch_system("SNES")
+
+
+async def test_send_keyboard(client):
+    with aioresponses() as m:
+        m.post(f"{BASE}/controls/keyboard/up", status=200)
+        await client.async_send_keyboard("up")
+
+
+async def test_reboot(client):
+    with aioresponses() as m:
+        m.post(f"{BASE}/settings/system/reboot", status=200)
+        await client.async_reboot()
+
+
+async def test_screenshot_image_returns_bytes(client):
+    with aioresponses() as m:
+        m.get(f"{BASE}/screenshots/SNES/shot.png", body=b"\x89PNG", status=200)
+        data = await client.async_get_screenshot_image("SNES", "shot.png")
+    assert data == b"\x89PNG"
+
+
+async def test_music_status(client):
+    with aioresponses() as m:
+        m.get(f"{BASE}/music/status", payload={"running": True, "playing": True})
+        status = await client.async_get_music_status()
+    assert status["playing"] is True
+
+
+@pytest.mark.parametrize(
+    ("method_name", "path"),
+    [
+        ("async_launch_menu", "/launch/menu"),
+        ("async_index_games", "/games/index"),
+        ("async_restart_remote", "/settings/remote/restart"),
+        ("async_take_screenshot", "/screenshots"),
+        ("async_music_play", "/music/play"),
+        ("async_music_stop", "/music/stop"),
+        ("async_music_next", "/music/next"),
+    ],
+)
+async def test_simple_post_methods(client, method_name, path):
+    with aioresponses() as m:
+        m.post(f"{BASE}{path}", status=200)
+        await getattr(client, method_name)()
+        assert any(k[0] == "POST" for k in m.requests)
+
+
+async def test_search_games(client):
+    with aioresponses() as m:
+        m.post(f"{BASE}/games/search", payload={"data": [], "total": 0})
+        result = await client.async_search_games("chrono", "SNES")
+    assert result["total"] == 0
+
+    with aioresponses() as m:
+        m.post(f"{BASE}/games/search", payload={"data": [], "total": 0})
+        await client.async_search_games("chrono", "SNES")
+        import yarl
+
+        key = ("POST", yarl.URL(f"{BASE}/games/search"))
+        assert m.requests[key][0].kwargs["json"] == {"data": "chrono", "system": "SNES"}
+
+
+async def test_get_screenshots(client):
+    with aioresponses() as m:
+        m.get(
+            f"{BASE}/screenshots",
+            payload=[{"core": "SNES", "filename": "a.png", "modified": "2026-05-30"}],
+        )
+        screenshots = await client.async_get_screenshots()
+    assert isinstance(screenshots, list)
+    assert screenshots[0]["filename"] == "a.png"
+
+
+async def test_get_wallpapers(client):
+    with aioresponses() as m:
+        m.get(
+            f"{BASE}/wallpapers",
+            payload={
+                "active": "snatcher.png",
+                "backgroundMode": 2,
+                "wallpapers": [
+                    {"name": "snatcher", "filename": "snatcher.png", "active": True}
+                ],
+            },
+        )
+        wp = await client.async_get_wallpapers()
+    assert wp["active"] == "snatcher.png"
+    assert wp["backgroundMode"] == 2
+
+
+async def test_set_and_clear_wallpaper(client):
+    with aioresponses() as m:
+        m.post(f"{BASE}/wallpapers/snatcher.png", status=200)
+        m.delete(f"{BASE}/wallpapers", status=200)
+        await client.async_set_wallpaper("snatcher.png")
+        await client.async_clear_wallpaper()
+
+
+async def test_inis_get_set_active(client):
+    import yarl
+
+    with aioresponses() as m:
+        m.get(
+            f"{BASE}/settings/inis",
+            payload={
+                "active": 0,
+                "inis": [
+                    {
+                        "id": 1,
+                        "displayName": "Main",
+                        "filename": "MiSTer.ini",
+                        "path": "/x",
+                    }
+                ],
+            },
+        )
+        m.get(
+            f"{BASE}/settings/inis/1",
+            payload={"__hostname": "MiSTer", "video_brightness": "50"},
+        )
+        m.put(f"{BASE}/settings/inis", status=200)
+        m.put(f"{BASE}/settings/inis/1", status=200)
+        inis = await client.async_get_inis()
+        values = await client.async_get_ini_values(1)
+        await client.async_set_active_ini(1)
+        await client.async_set_ini_values(1, {"video_brightness": "60"})
+        put_inis_calls = m.requests[
+            ("PUT", yarl.URL(f"{BASE}/settings/inis"))
+        ]
+        put_inis_1_calls = m.requests[
+            ("PUT", yarl.URL(f"{BASE}/settings/inis/1"))
+        ]
+    assert inis["inis"][0]["displayName"] == "Main"
+    assert values["video_brightness"] == "50"
+    assert put_inis_calls[0].kwargs["json"] == {"ini": 1}
+    assert put_inis_1_calls[0].kwargs["json"] == {"video_brightness": "60"}
+
+
+async def test_set_background_mode(client):
+    import yarl
+
+    with aioresponses() as m:
+        m.put(f"{BASE}/settings/core/menu", status=200)
+        await client.async_set_background_mode(3)
+        put_calls = m.requests[("PUT", yarl.URL(f"{BASE}/settings/core/menu"))]
+    assert put_calls[0].kwargs["json"] == {"mode": 3}
+
+
+async def test_music_playlists_and_playback(client):
+    with aioresponses() as m:
+        m.get(f"{BASE}/music/playlist", payload=["none", "Vidya"])
+        m.post(f"{BASE}/music/playlist/Vidya", status=200)
+        m.post(f"{BASE}/music/playback/loop", status=200)
+        pls = await client.async_get_music_playlists()
+        await client.async_set_music_playlist("Vidya")
+        await client.async_set_music_playback("loop")
+    assert pls == ["none", "Vidya"]
+
+
+async def test_scripts_list_launch_kill_console(client):
+    with aioresponses() as m:
+        m.get(
+            f"{BASE}/scripts/list",
+            payload={
+                "canLaunch": True,
+                "scripts": [
+                    {"name": "update_all", "filename": "update_all.sh", "path": "/x"}
+                ],
+            },
+        )
+        m.post(f"{BASE}/scripts/launch/update_all.sh", status=200)
+        m.post(f"{BASE}/scripts/console", status=200)
+        m.post(f"{BASE}/scripts/kill", status=200)
+        scr = await client.async_get_scripts()
+        await client.async_launch_script("update_all.sh")
+        await client.async_open_console()
+        await client.async_kill_script()
+    assert scr["scripts"][0]["filename"] == "update_all.sh"
+
+
+async def test_peers(client):
+    with aioresponses() as m:
+        m.get(
+            f"{BASE}/settings/remote/peers",
+            payload={
+                "peers": [
+                    {"hostname": "MiSTer.local", "version": "0.4", "ip": "1.2.3.4"}
+                ]
+            },
+        )
+        peers = await client.async_get_peers()
+    assert peers[0]["ip"] == "1.2.3.4"
+
+
+async def test_generic_launch_and_token(client):
+    with aioresponses() as m:
+        m.post(f"{BASE}/launch", status=200)
+        m.get(f"{BASE}/l/bWVudS5yYmY=", status=200)
+        await client.async_launch_path("/media/fat/menu.rbf")
+        await client.async_launch_token("bWVudS5yYmY=")
+
+
+async def test_create_shortcut(client):
+    with aioresponses() as m:
+        m.post(
+            f"{BASE}/launch/new",
+            payload={"path": "/media/fat/_@Favorites/Crash.mgl"},
+        )
+        result = await client.async_create_shortcut(
+            "/g/Crash.chd", "_@Favorites", "Crash"
+        )
+    assert result["path"].endswith("Crash.mgl")
+
+
+async def test_send_keyboard_raw(client):
+    with aioresponses() as m:
+        m.post(f"{BASE}/controls/keyboard-raw/16", status=200)
+        await client.async_send_keyboard_raw(16)

python_mister_fpga-0.1.0/tests/test_ssh.py

@@ -0,0 +1,25 @@
+"""Tests for the optional SSH telemetry parsing."""
+from __future__ import annotations
+
+from mister_fpga.ssh import parse_ssh_probe
+
+
+def test_parse_ssh_probe_full():
+    raw = (
+        "SNES\n|||\n123456.78 100.0\n|||\n0.50 0.40 0.30 1/98 1234"
+        "\n|||\n1048576\n524288\n|||\n1742860800"
+    )
+    data = parse_ssh_probe(raw)
+    assert data["active_core"] == "SNES"
+    assert data["uptime_seconds"] == 123456
+    assert data["cpu_load_1m"] == 0.50
+    assert data["memory_used_percent"] == 50.0
+    assert data["firmware_timestamp"] == 1742860800
+
+
+def test_parse_ssh_probe_partial_is_tolerant():
+    raw = "MENU\n|||\n\n|||\n\n|||\n\n|||\n"
+    data = parse_ssh_probe(raw)
+    assert data["active_core"] == "MENU"
+    assert data["uptime_seconds"] is None
+    assert data["memory_used_percent"] is None

python_mister_fpga-0.1.0/tests/test_websocket.py

@@ -0,0 +1,80 @@
+"""Tests for the MiSTer FPGA WebSocket message parsing."""
+from __future__ import annotations
+
+from mister_fpga.client import MisterStatus
+from mister_fpga.websocket import MisterWebSocketClient, apply_ws_message
+
+
+def test_core_running_updates_status():
+    status = MisterStatus(online=True, core="MENU")
+    new, menu, idx = apply_ws_message("coreRunning:SNES", status, None, (False, False))
+    assert new.core == "SNES"
+
+
+def test_core_running_blank_means_menu():
+    status = MisterStatus(online=True, core="SNES", game="x", game_name="X")
+    new, menu, idx = apply_ws_message("coreRunning:", status, None, (False, False))
+    assert new.core is None
+    assert new.game is None
+
+
+def test_game_running_updates_status():
+    status = MisterStatus(online=True, core="SNES")
+    new, menu, idx = apply_ws_message(
+        "gameRunning:SNES/Chrono.sfc", status, None, (False, False)
+    )
+    assert new.game == "SNES/Chrono.sfc"
+    assert new.game_name == "Chrono"
+
+
+def test_menu_navigation_sets_path():
+    status = MisterStatus(online=True)
+    new, menu, idx = apply_ws_message(
+        "menuNavigation:_Console/SNES", status, None, (False, False)
+    )
+    assert menu == "_Console/SNES"
+
+
+def test_index_status_parsed():
+    status = MisterStatus(online=True)
+    new, menu, (exists, in_progress) = apply_ws_message(
+        "indexStatus:y,n,0,0,", status, None, (False, False)
+    )
+    assert exists is True
+    assert in_progress is False
+
+
+def test_unknown_message_is_noop():
+    status = MisterStatus(online=True, core="SNES")
+    new, menu, idx = apply_ws_message(
+        "somethingElse:42", status, "_Console", (True, False)
+    )
+    assert new.core == "SNES"
+    assert menu == "_Console"
+    assert idx == (True, False)
+
+
+def test_game_running_preserves_dots_and_spaces():
+    status = MisterStatus(online=True, core="PSX")
+    new, menu, idx = apply_ws_message(
+        "gameRunning:PSX/Crash Bandicoot (USA).chd", status, None, (False, False)
+    )
+    assert new.game == "PSX/Crash Bandicoot (USA).chd"
+    assert new.game_name == "Crash Bandicoot (USA)"
+
+
+def test_websocket_client_url():
+    ws = MisterWebSocketClient("192.168.1.50")
+    assert ws.url == "ws://192.168.1.50:8182/api/ws"
+
+
+def test_websocket_client_url_custom_port():
+    ws = MisterWebSocketClient("h", port=9000)
+    assert ws.url == "ws://h:9000/api/ws"
+
+
+def test_websocket_client_stop_sets_flag():
+    ws = MisterWebSocketClient("h")
+    assert ws._stop is False
+    ws.stop()
+    assert ws._stop is True