cbrm 0.1.0__py3-none-any.whl

cbrm/__init__.py

@@ -0,0 +1,6 @@
+"""cbrm — BERO HOST management. `Panel` drives the customer panel, `Console` its VNC console."""
+from .panel import Panel, PanelError
+from .console import Console
+
+__all__ = ["Panel", "PanelError", "Console"]
+__version__ = "0.1.0"

cbrm/api.py

@@ -0,0 +1,73 @@
+"""HTTP API (FastAPI; OpenAPI at /openapi.json, docs at /docs). It holds the panel credential, so CLIs
+and MCP servers elsewhere only need the API URL and its token. Every route needs the bearer token."""
+from __future__ import annotations
+
+import os
+import secrets
+
+from fastapi import Depends, FastAPI, HTTPException, Request
+from fastapi.responses import JSONResponse, Response
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+from pydantic import BaseModel
+
+from . import __version__
+from .panel import PanelError
+from .service import Service, ServiceError
+
+_bearer = HTTPBearer()
+
+
+def _auth(cred: HTTPAuthorizationCredentials = Depends(_bearer)) -> None:
+    token = os.environ.get("CBRM_API_TOKEN", "")
+    if not token or not secrets.compare_digest(cred.credentials, token):
+        raise HTTPException(401, "bad token")
+
+
+class PowerRequest(BaseModel):
+    action: str
+    confirm: str
+
+
+class ConsoleInput(BaseModel):
+    text: str = ""
+    keys: list[str] = []
+    confirm: str
+
+
+def create_app(service: Service) -> FastAPI:
+    app = FastAPI(title="cbrm", version=__version__, dependencies=[Depends(_auth)],
+                  description="BERO HOST management: panel and VNC console.")
+
+    @app.exception_handler(ServiceError)
+    async def refused(_: Request, e: ServiceError):
+        return JSONResponse({"detail": str(e)}, status_code=403)
+
+    @app.exception_handler(PanelError)
+    async def panel(_: Request, e: PanelError):
+        return JSONResponse({"detail": str(e)}, status_code=502)
+
+    @app.get("/vms")
+    def vms() -> list[dict]:
+        return service.vms()
+
+    @app.get("/vms/{vm}")
+    def status(vm: str) -> dict:
+        return service.status(vm)
+
+    @app.get("/vms/{vm}/logs")
+    def logs(vm: str, n: int = 20) -> list[dict]:
+        return service.logs(vm, n)
+
+    @app.get("/vms/{vm}/console.png", response_class=Response)
+    def console(vm: str) -> Response:
+        return Response(service.console_png(vm), media_type="image/png")
+
+    @app.post("/vms/{vm}/power")
+    def power(vm: str, body: PowerRequest) -> dict:
+        return service.power(vm, body.action, body.confirm)
+
+    @app.post("/vms/{vm}/console/input")
+    def console_input(vm: str, body: ConsoleInput) -> dict:
+        return service.console_input(vm, body.text, body.keys, body.confirm)
+
+    return app

cbrm/cli.py

@@ -0,0 +1,68 @@
+"""cbrm command line: the same operations as the API and the MCP server (see cbrm.config for setup)."""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+
+from .panel import POWER_ACTIONS, PanelError
+from .service import ServiceError
+
+
+def main(argv: list[str] | None = None) -> None:
+    p = argparse.ArgumentParser(prog="cbrm", description="BERO HOST management: panel and VNC console.")
+    p.add_argument("--json", action="store_true", help="machine-readable output")
+    sub = p.add_subparsers(dest="cmd", required=True)
+    sub.add_parser("vms", help="all VMs of the account")
+    sub.add_parser("status").add_argument("vm")
+    s = sub.add_parser("logs"); s.add_argument("vm"); s.add_argument("-n", type=int, default=20)
+    s = sub.add_parser("console", help="screenshot of the VNC console"); s.add_argument("vm"); s.add_argument("out")
+    s = sub.add_parser("power", help="changes the VM"); s.add_argument("vm"); s.add_argument("action", choices=POWER_ACTIONS)
+    s.add_argument("--confirm", required=True, metavar="VM", help="repeat the target VM")
+    s = sub.add_parser("input", help="type text and/or press keys on the console (changes the VM)")
+    s.add_argument("vm"); s.add_argument("--text", default=""); s.add_argument("--key", action="append", default=[],
+                                                                              help="vncdotool key name, repeatable")
+    s.add_argument("--confirm", required=True, metavar="VM", help="repeat the target VM")
+    s = sub.add_parser("serve", help="run the HTTP API (needs CBRM_API_TOKEN)")
+    s.add_argument("--host", default="127.0.0.1"); s.add_argument("--port", type=int, default=8765)
+    a = p.parse_args(argv)
+
+    def out(obj, text: str) -> None:
+        print(json.dumps(obj, ensure_ascii=False) if a.json else text)
+
+    if a.cmd == "serve":
+        import uvicorn
+        from .api import create_app
+        from .config import credentials
+        from .panel import Panel
+        from .service import Service
+        if not os.environ.get("CBRM_API_TOKEN"):
+            sys.exit("cbrm: serve needs CBRM_API_TOKEN")
+        uvicorn.run(create_app(Service(Panel(*credentials()))), host=a.host, port=a.port)
+        return
+
+    from .client import backend
+    b = backend()
+    try:
+        if a.cmd == "vms":
+            rows = b.vms()
+            out(rows, "\n".join(f"{r['vm']} {r['state']} {r.get('ipv4', '')} {r.get('system', '')}" for r in rows))
+        elif a.cmd == "status":
+            s = b.status(a.vm); out(s, "\n".join(f"{k}: {v}" for k, v in s.items()))
+        elif a.cmd == "logs":
+            e = b.logs(a.vm, a.n); out(e, "\n".join(f"{x['date']} {x['action']}" for x in e))
+        elif a.cmd == "console":
+            with open(a.out, "wb") as f:
+                f.write(b.console_png(a.vm))
+            out({"file": a.out}, a.out)
+        elif a.cmd == "power":
+            r = b.power(a.vm, a.action, a.confirm); out(r, r.get("message", json.dumps(r)))
+        elif a.cmd == "input":
+            out(b.console_input(a.vm, a.text, a.key, a.confirm), "sent")
+    except (ServiceError, PanelError) as e:
+        sys.exit(f"cbrm: {e}")
+
+
+if __name__ == "__main__":
+    main()

cbrm/client.py

@@ -0,0 +1,41 @@
+"""The Service interface over the HTTP API, so the CLI and the MCP server work the same whether they
+run next to the credential (in-process Service) or against a remote `cbrm serve` (CBRM_API_URL)."""
+from __future__ import annotations
+
+import httpx
+
+from .service import ServiceError
+
+
+class Client:
+    def __init__(self, url: str, token: str):
+        self.http = httpx.Client(base_url=url.rstrip("/"), headers={"Authorization": f"Bearer {token}"},
+                                 timeout=120)
+
+    def _do(self, method: str, path: str, **kw):
+        r = self.http.request(method, path, **kw)
+        if r.status_code == 403:
+            raise ServiceError(r.json().get("detail", "refused"))
+        r.raise_for_status()
+        return r
+
+    def vms(self): return self._do("GET", "/vms").json()
+    def status(self, vm): return self._do("GET", f"/vms/{vm}").json()
+    def logs(self, vm, n=20): return self._do("GET", f"/vms/{vm}/logs", params={"n": n}).json()
+    def console_png(self, vm): return self._do("GET", f"/vms/{vm}/console.png").content
+    def power(self, vm, action, confirm):
+        return self._do("POST", f"/vms/{vm}/power", json={"action": action, "confirm": confirm}).json()
+    def console_input(self, vm, text="", keys=None, confirm=""):
+        return self._do("POST", f"/vms/{vm}/console/input",
+                        json={"text": text, "keys": keys or [], "confirm": confirm}).json()
+
+
+def backend():
+    """CBRM_API_URL (+ CBRM_API_TOKEN) -> remote API client; otherwise the in-process Service."""
+    import os
+    if os.environ.get("CBRM_API_URL"):
+        return Client(os.environ["CBRM_API_URL"], os.environ.get("CBRM_API_TOKEN", ""))
+    from .config import credentials
+    from .panel import Panel
+    from .service import Service
+    return Service(Panel(*credentials()))

cbrm/config.py

@@ -0,0 +1,20 @@
+"""Configuration from the environment.
+CBRM_USER + CBRM_PASSWORD, or CBRM_CREDENTIALS_CMD (prints user and password on two lines): the panel login.
+CBRM_VMS: space-separated allow-list. CBRM_API_URL + CBRM_API_TOKEN: use a remote `cbrm serve` instead."""
+from __future__ import annotations
+
+import os
+import shlex
+import subprocess
+
+
+def credentials() -> tuple[str, str]:
+    if os.environ.get("CBRM_USER") and os.environ.get("CBRM_PASSWORD"):
+        return os.environ["CBRM_USER"], os.environ["CBRM_PASSWORD"]
+    cmd = os.environ.get("CBRM_CREDENTIALS_CMD")
+    if not cmd:
+        raise SystemExit("cbrm: set CBRM_USER/CBRM_PASSWORD, CBRM_CREDENTIALS_CMD, or CBRM_API_URL")
+    lines = subprocess.run(shlex.split(cmd), capture_output=True, text=True, check=True).stdout.splitlines()
+    if len(lines) < 2:
+        raise SystemExit("cbrm: CBRM_CREDENTIALS_CMD must print the user and the password on two lines")
+    return lines[0], lines[1]

cbrm/console.py

@@ -0,0 +1,82 @@
+"""The panel's VNC console: a Proxmox noVNC websocket. A local TCP port is bridged to that websocket
+so a normal VNC client (vncdotool) can capture the screen and send keys."""
+from __future__ import annotations
+
+import asyncio
+import atexit
+import ssl
+import threading
+
+import websockets
+from vncdotool import api as vnc
+
+# vncdotool runs one Twisted reactor per process and cannot restart it: stop it once, at exit,
+# so long-running servers (API, MCP) can open many console sessions.
+atexit.register(vnc.shutdown)
+
+
+class Console:
+    """Use as a context manager: `with Console(host, port, ticket) as c: c.capture("out.png")`."""
+
+    def __init__(self, host: str, port: int, password: str):
+        self.url, self.password = f"wss://{host}:{port}/websockify", password
+        self._loop = asyncio.new_event_loop()
+        self._thread = threading.Thread(target=self._loop.run_forever, daemon=True)
+        self.client = None
+
+    async def _bridge(self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter) -> None:
+        async with websockets.connect(self.url, subprotocols=["binary"], ssl=ssl.create_default_context(),
+                                      max_size=None) as ws:
+            async def up():
+                while data := await reader.read(65536):
+                    await ws.send(data)
+            async def down():
+                async for msg in ws:
+                    writer.write(msg if isinstance(msg, bytes) else msg.encode())
+                    await writer.drain()
+            await asyncio.wait([asyncio.ensure_future(up()), asyncio.ensure_future(down())],
+                               return_when=asyncio.FIRST_COMPLETED)
+        writer.close()
+
+    def __enter__(self) -> "Console":
+        self._thread.start()
+        self._server = asyncio.run_coroutine_threadsafe(
+            asyncio.start_server(self._bridge, "127.0.0.1", 0), self._loop).result(10)
+        port = self._server.sockets[0].getsockname()[1]
+        self.client = vnc.connect(f"127.0.0.1::{port}", password=self.password, timeout=30)
+        return self
+
+    def __exit__(self, *exc) -> None:
+        try:
+            if self.client:
+                self.client.disconnect()
+        finally:
+            asyncio.run_coroutine_threadsafe(self._close(), self._loop).result(10)
+            self._loop.call_soon_threadsafe(self._loop.stop)
+            self._thread.join(5)
+
+    async def _close(self) -> None:
+        self._server.close()
+        tasks = [t for t in asyncio.all_tasks() if t is not asyncio.current_task()]
+        for t in tasks:
+            t.cancel()
+        await asyncio.gather(*tasks, return_exceptions=True)
+
+    def capture(self, path: str) -> str:
+        self.client.captureScreen(path)
+        return path
+
+    def png(self) -> bytes:
+        import io
+        self.client.refreshScreen()
+        buf = io.BytesIO()
+        self.client.screen.save(buf, "PNG")
+        return buf.getvalue()
+
+    def type(self, text: str) -> None:
+        for ch in text:
+            self.client.keyPress(ch)
+
+    def keys(self, *names: str) -> None:
+        for name in names:  # vncdotool key names: enter, ctrl-c, alt-f2, f1, ...
+            self.client.keyPress(name)

cbrm/mcp.py

@@ -0,0 +1,62 @@
+"""MCP server (stdio) for AI clients. Same operations and rules as the CLI and the API; with
+CBRM_API_URL set it is a client of a remote `cbrm serve` and never sees the panel credential."""
+from __future__ import annotations
+
+from mcp.server.fastmcp import FastMCP, Image
+
+from .client import backend
+
+mcp = FastMCP("cbrm", instructions=(
+    "Manage BERO HOST (bero-host.de) KVM rootservers through the customer panel and the VNC console. "
+    "Read first (bero_vms, bero_status, bero_logs, bero_console). Changing tools need confirm=<vm>. "
+    "`system` in the status is the last template BERO installed, not necessarily what runs. "
+    "Reinstall, backups, root password, network reset and billing are deliberately not available."))
+_b = None
+
+
+def b():
+    global _b
+    if _b is None:
+        _b = backend()
+    return _b
+
+
+@mcp.tool()
+def bero_vms() -> list[dict]:
+    """All KVM rootservers of the account: state, addresses, last installed template."""
+    return b().vms()
+
+
+@mcp.tool()
+def bero_status(vm: str) -> dict:
+    """Overview of one VM (state, hostname, addresses, last backup)."""
+    return b().status(vm)
+
+
+@mcp.tool()
+def bero_logs(vm: str, n: int = 20) -> list[dict]:
+    """The panel's action log of a VM, newest first, in panel time (Europe/Berlin)."""
+    return b().logs(vm, n)
+
+
+@mcp.tool()
+def bero_console(vm: str) -> Image:
+    """A screenshot of the VM's VNC console (what a monitor would show)."""
+    return Image(data=b().console_png(vm), format="png")
+
+
+@mcp.tool()
+def bero_power(vm: str, action: str, confirm: str) -> dict:
+    """Power action on a VM: start, stop, shutdown or restart. confirm must repeat the VM id."""
+    return b().power(vm, action, confirm)
+
+
+@mcp.tool()
+def bero_console_input(vm: str, confirm: str, text: str = "", keys: list[str] | None = None) -> dict:
+    """Type text, then press keys (vncdotool names: enter, ctrl-c, f1, ...) on the VNC console.
+    confirm must repeat the VM id. Look at bero_console before and after."""
+    return b().console_input(vm, text, keys, confirm)
+
+
+def main() -> None:
+    mcp.run()

cbrm/panel.py

@@ -0,0 +1,158 @@
+"""The BERO HOST customer panel (bero-host.de) has no API. This module speaks the panel's own HTTP:
+a form login, server-rendered pages, one Livewire request for the action log, and the JSON endpoints
+its power buttons call. Only reading and power exist here; everything else stays in the panel."""
+from __future__ import annotations
+
+import json
+import os
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+import httpx
+from selectolax.lexbor import LexborHTMLParser as HTMLParser
+
+BASE = "https://bero-host.de"
+POWER_ACTIONS = ("start", "stop", "shutdown", "restart")
+
+
+class PanelError(RuntimeError):
+    pass
+
+
+@dataclass
+class LogEntry:
+    date: str    # panel time (Europe/Berlin), as the panel shows it: "11.10.2026 00:02"
+    action: str  # e.g. "Rootserver installieren", "Neustarten"
+
+
+def _lines(html: str) -> list[str]:
+    tree = HTMLParser(html)
+    for node in tree.css("script, style"):
+        node.decompose()
+    root = tree.body or tree.root
+    return [l.strip() for l in root.text(separator="\n").splitlines() if l.strip()]
+
+
+class Panel:
+    """A logged-in panel session. Cookies persist in `state_dir` (mode 0600) between runs."""
+
+    def __init__(self, user: str, password: str, state_dir: Path | None = None):
+        self._user, self._password = user, password
+        self.state_dir = state_dir or Path(os.environ.get("XDG_STATE_HOME", Path.home() / ".local/state")) / "cbrm"
+        self.state_dir.mkdir(parents=True, exist_ok=True, mode=0o700)
+        self._cookies = self.state_dir / "cookies.json"
+        jar = httpx.Cookies()
+        if self._cookies.exists():
+            for name, value in json.loads(self._cookies.read_text()).items():
+                jar.set(name, value, domain="bero-host.de")
+        self.http = httpx.Client(base_url=BASE, cookies=jar, timeout=60,
+                                 headers={"User-Agent": "cbrm (+https://git.corbet.ch/corbet-infra/cbrm)"})
+        self._products: dict[str, str] | None = None
+
+    # -- session -----------------------------------------------------------------------------
+    def _save(self) -> None:
+        fd = os.open(self._cookies, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)  # never readable by others
+        with os.fdopen(fd, "w") as f:
+            json.dump({c.name: c.value for c in self.http.cookies.jar}, f)
+
+    def _login(self) -> None:
+        form = HTMLParser(self.http.get("/login").text).css_first("form[action$='/login'] input[name=_token]")
+        if form is None:
+            raise PanelError("login form not found")
+        r = self.http.post("/login", data={"_token": form.attributes["value"], "email": self._user,
+                                            "password": self._password})
+        if r.status_code != 302 or "/login" in r.headers.get("location", ""):
+            raise PanelError("login failed")
+        self._save()
+
+    def page(self, path: str) -> str:
+        """GET a panel page, logging in again when the session has expired."""
+        r = self.http.get(path)
+        if r.status_code == 302 and "/login" in r.headers.get("location", ""):
+            self._login()
+            r = self.http.get(path)
+        r.raise_for_status()
+        return r.text
+
+    # -- reading -----------------------------------------------------------------------------
+    def products(self) -> dict[str, str]:
+        """VM id -> product id, for every KVM rootserver in the account."""
+        if self._products is None:
+            ids = sorted(set(re.findall(r"/customer/products/(\d+)", self.page("/customer"))))
+            self._products = {}
+            for pid in ids:
+                title = HTMLParser(self.page(f"/customer/products/{pid}")).css_first("title").text()
+                m = re.search(r"#(\d+) \(KVM Rootserver #%s\)" % pid, title)
+                if m:
+                    self._products[m.group(1)] = pid
+        return self._products
+
+    def _product_page(self, vm: str) -> str:
+        pid = self.products().get(vm)
+        if pid is None:
+            raise PanelError(f"VM {vm} is not in this account")
+        return self.page(f"/customer/products/{pid}")
+
+    def status(self, vm: str) -> dict[str, str]:
+        """Overview fields. `system` is the last template BERO installed, not what is running now."""
+        lines = _lines(self._product_page(vm))
+        i = next(k for k, l in enumerate(lines) if l.startswith("KVM Rootserver #"))
+        out = {"vm": vm, "state": lines[i + 1]}
+        names = {"Hostname": "hostname", "Installiertes System": "system", "Haupt IP-Adressen": "ipv4"}
+        for k in range(i, min(len(lines) - 2, i + 80)):
+            if lines[k] in names:
+                out[names[lines[k]]] = lines[k + 1]
+            if lines[k] == "Haupt IP-Adressen":
+                out["ipv6"] = lines[k + 2]
+            if lines[k].startswith("Letztes Backup"):
+                out["last_backup"] = lines[k].split(":", 1)[1].strip() or lines[k + 1]
+                break
+        return out
+
+    def logs(self, vm: str) -> list[LogEntry]:
+        """The panel's action log, newest first. It is a lazy Livewire component: replay its
+        __lazyLoad call with the component's own snapshot."""
+        html = self._product_page(vm)
+        tree = HTMLParser(html)
+        csrf = tree.css_first("meta[name=csrf-token]").attributes["content"]
+        uri = tree.css_first("[data-update-uri]").attributes["data-update-uri"]
+        for node in tree.css("[wire\\:snapshot][x-intersect]"):
+            snapshot = node.attributes["wire:snapshot"]
+            if json.loads(snapshot)["memo"]["name"].endswith(".logs-table"):
+                param = re.search(r"__lazyLoad\('([^']+)'\)", node.attributes["x-intersect"]).group(1)
+                break
+        else:
+            raise PanelError("log component not found")
+        r = self.http.post(uri, headers={"X-Livewire": "true", "X-CSRF-TOKEN": csrf}, json={
+            "_token": csrf, "components": [{"snapshot": snapshot, "updates": {},
+                                            "calls": [{"path": "", "method": "__lazyLoad", "params": [param]}]}]})
+        r.raise_for_status()
+        # Rows read "Datum : 11.10.2026 | 00:02 Uhr  Aktion: Starten"; line breaks vary with the parser.
+        lines = _lines(r.json()["components"][0]["effects"]["html"])
+        entries, date = [], None
+        for k, line in enumerate(lines):
+            if m := re.search(r"(\d{2}\.\d{2}\.\d{4}) \| (\d{2}:\d{2})", line):
+                date = f"{m.group(1)} {m.group(2)}"
+            elif line.startswith("Aktion:") and date and k + 1 < len(lines):
+                entries.append(LogEntry(date, line[len("Aktion:"):].strip() or lines[k + 1]))
+                date = None
+        return entries
+
+    def console_session(self, vm: str) -> tuple[str, int, str]:
+        """(host, port, password) of a fresh noVNC session. The password is a Proxmox VNC ticket."""
+        src = HTMLParser(self.page(f"/customer/rootserver/{vm}/vnc")).css_first("iframe").attributes["src"]
+        q = httpx.URL(src).params
+        if not (q.get("host") and q.get("port") and q.get("password")):
+            raise PanelError(f"no console session offered for {vm}")
+        return q["host"], int(q["port"]), q["password"]
+
+    # -- changing ----------------------------------------------------------------------------
+    def power(self, vm: str, action: str) -> dict:
+        if action not in POWER_ACTIONS:
+            raise PanelError(f"power action must be one of {POWER_ACTIONS}")
+        self._product_page(vm)  # also proves the VM belongs to this account
+        r = self.http.get(f"/customer/rootserver/{vm}/{action}",
+                          headers={"X-Requested-With": "XMLHttpRequest", "Accept": "application/json"})
+        r.raise_for_status()
+        return r.json()

cbrm/service.py

@@ -0,0 +1,66 @@
+"""The operations every interface offers (CLI, HTTP API, MCP), with the rules in one place:
+the allow-list, the repeated target for anything that changes a VM, and the audit log."""
+from __future__ import annotations
+
+import datetime
+import os
+from pathlib import Path
+
+from .panel import POWER_ACTIONS, Panel
+
+
+class ServiceError(ValueError):
+    """The request is refused (unknown VM, missing confirmation, ...)."""
+
+
+class Service:
+    def __init__(self, panel: Panel, allow: list[str] | None = None, audit: Path | None = None):
+        self.panel = panel
+        self.allow = allow if allow is not None else os.environ.get("CBRM_VMS", "").split()
+        self.audit_path = audit or panel.state_dir / "audit.log"
+
+    def _audit(self, line: str) -> None:
+        fd = os.open(self.audit_path, os.O_WRONLY | os.O_CREAT | os.O_APPEND, 0o600)
+        with os.fdopen(fd, "a") as f:
+            f.write(f"{datetime.datetime.now(datetime.timezone.utc):%Y-%m-%dT%H:%M:%SZ} {line}\n")
+
+    def _vm(self, vm: str, confirm: str | None = None, changing: bool = False) -> str:
+        if self.allow and vm not in self.allow:
+            raise ServiceError(f"VM {vm} is not in the allow-list")
+        if changing and confirm != vm:
+            raise ServiceError(f"this changes VM {vm}: repeat it as confirm={vm}")
+        return vm
+
+    # reading
+    def vms(self) -> list[dict]:
+        return [self.panel.status(v) for v in sorted(self.panel.products()) if not self.allow or v in self.allow]
+
+    def status(self, vm: str) -> dict:
+        return self.panel.status(self._vm(vm))
+
+    def logs(self, vm: str, n: int = 20) -> list[dict]:
+        return [e.__dict__ for e in self.panel.logs(self._vm(vm))[:n]]
+
+    def console_png(self, vm: str) -> bytes:
+        from .console import Console
+        with Console(*self.panel.console_session(self._vm(vm))) as c:
+            return c.png()
+
+    # changing
+    def power(self, vm: str, action: str, confirm: str) -> dict:
+        self._vm(vm, confirm, changing=True)
+        if action not in POWER_ACTIONS:
+            raise ServiceError(f"action must be one of {', '.join(POWER_ACTIONS)}")
+        self._audit(f"power {vm} {action} requested")
+        r = self.panel.power(vm, action)
+        self._audit(f"power {vm} {action} -> {r}")
+        return r
+
+    def console_input(self, vm: str, text: str = "", keys: list[str] | None = None, confirm: str = "") -> dict:
+        self._vm(vm, confirm, changing=True)
+        self._audit(f"console {vm} text={len(text)} chars keys={' '.join(keys or [])}")
+        from .console import Console
+        with Console(*self.panel.console_session(vm)) as c:
+            c.type(text)
+            c.keys(*(keys or []))
+        return {"sent": True}