Health of both subsystems: LCU (lockfile-derived port, connected state) and CDP (Pengu remote debugging port, attached target), plus event tap state and effective config. Call this first when another tool fails.

GET any LCU path and return { status, body }. Always allowed. Use lol_endpoints to discover the paths this client is known to expose.

Send any HTTP verb to an LCU path. GET and HEAD are always allowed; every other verb must match an entry in the write allowlist, otherwise the call is refused with the exact config line that would permit it.

The curated endpoint table: the LCU paths this project actually uses, with the verb, a group, and a one-line description. {placeholder} marks a path parameter. Optional filter is a case-insensitive substring matched against verb, path, group, and description.

Inspect internal LCU API endpoint signatures, parameters, request bodies, and models using the client's live OpenAPI/Swagger v2 specification.

Open the OnJsonApiEvent tap and buffer events in memory. Filters are URI prefixes applied at ingest, e.g. "/lol-champ-select/" — the unfiltered firehose fills the buffer in seconds, so pass filters unless you truly want everything. Calling this while already running replaces the filters and keeps buffered entries.

Return buffered events with seq greater than "since", plus the new cursor. A non-zero "dropped" means the buffer wrapped and that many events were lost after your cursor. Entries with truncated: true had their data clipped at 4 KB — re-fetch the full body with lol_get on the entry uri.

Close the event tap. Buffered entries stay readable with lol_events_poll.

Run document.querySelector(All) inside the client UI and return a description of the matches (tag, id, className, trimmed text, plus any requested properties). Needs Pengu Loader's remote debugging port; check lol_status if it fails.

Evaluate an expression in the client UI's own context and return its value. Because the page can fetch any LCU endpoint from its own origin, this bypasses the write allowlist by construction — it is gated by the allowEval config flag, whose state lol_status reports.

Open a second WAMP socket to the LCU, independent of lol_events_*, and record every frame plus the socket lifecycle (open, close with its code, error, reconnect gap) into one timeline. Defaults to the firehose, which is what lets you tell "the socket died" (every URI goes quiet at once) from "nothing happened" (one URI quiet, others flowing). Passing uris subscribes per URI instead, which reproduces what a page-side plugin sees but cannot distinguish those two cases. Starting while a recording is already running is an error: pass restart to discard the old one.

Return the recorded timeline plus per-URI stats. "stats" is cumulative since the recording started and survives buffer eviction, so a URI that fired and was evicted is still distinguishable from one that never fired. A non-zero "dropped" means entries after your cursor were evicted. Lifecycle entries survive a uri filter; only "kinds" can exclude them. Times are epoch milliseconds, comparable with the page clock.

Close the recorder socket. The recorded timeline stays readable with lol_wamp_record_dump.

Attach to the client renderer and begin buffering console output and uncaught exceptions in the background. A page reload does not interrupt this: the debug target survives it, so logging continues with no gap and no reattach entry. Only when the target itself is destroyed and recreated — the client UI restarting — does the tailer re-attach, and it records a "reattach" entry for that. Call this BEFORE the thing you want to capture: the buffer only holds what arrived after it started.

Return buffered console entries after your cursor. Times are epoch milliseconds: "ts" is this process's anchored clock, "pageTs" is the renderer's own stamp, and their difference is a delivery-latency signal. "reattach" entries mark renderer reloads and survive every filter, because a reload is context for whatever you are reading. Errors if the tailer is not running rather than returning an empty result.

Detach and close the tailer socket. Buffered entries are discarded with it.

Terminates and restarts the League Client UX (frontend CEF renderers) via Riot Client. Essential when developing Pengu Loader plugins or recovering from a frozen interface.

List all active CDP debugging targets (pages, popups, background workers) exposed by the League Client.

Capture a screenshot of the League Client window using CDP. Returns both an MCP image content block and JSON metadata, and optionally saves to disk.

Combines WAMP recorder events and CDP console entries into a chronological timeline, answering whether the client emitted an event and where the frontend broke.