diff --git a/tools/computer-client-test.py b/tools/computer-client-test.py new file mode 100644 index 0000000000000000000000000000000000000000..dc50038eea4989b673d65b56e958fbbc583175ec --- /dev/null +++ b/tools/computer-client-test.py @@ -0,0 +1,202 @@ +#!/usr/bin/env python3 +"""computer.py against a local dashboard whose host socket is a stub with one VM.""" +import argparse +import base64 +import http.client +import json +import os +import socket +import socketserver +import sqlite3 +import struct +import subprocess +import sys +import tempfile +import threading +import time +import unittest +from pathlib import Path +from urllib.parse import urlsplit +from urllib.request import Request + +sys.path.insert(0, str(Path(__file__).parent)) +import computer # noqa: E402 + +PNG = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAusB9Wl6qWQAAAAASUVORK5CYII=" +HOST = "snowglobe.paperclover.net" + + +class Host(socketserver.StreamRequestHandler): + owner = None + files = {} + + def handle(self): + request = json.loads(self.rfile.readline()) + try: + reply = {"value": self.answer(request["operation"], request.get("payload") or {})} + except KeyError as missing: + reply = {"error": f"missing {missing}", "status": 404} + body = json.dumps(reply).encode() + try: + self.wfile.write(struct.pack(">I", len(body)) + body) + except BrokenPipeError: + pass # The dashboard can drop a request before its reply. + + def answer(self, operation, payload): + if operation == "vm.computers": + return [{"name": "test-vm", "owner": self.owner, "capabilities": ["computer"], "platform": "linux", + "os": "Fedora", "arch": "x86_64", "state": "running", "aiOwned": False}] + if operation == "vm.owner": + return {"owner": self.owner} + if operation != "vm.computer": + raise KeyError(operation) + request, files = payload["request"], self.files + if request["action"] == "exec": + return {"exit": 0, "stdout": "ran " + request["script"], "png": PNG} + if request["action"] == "shot": + return {"png": PNG} + operation, path = request["operation"], request["path"] + if operation == "stat": + return {"directory": True} if path.endswith("/") else {"directory": False, "size": len(files[path])} + if operation == "write": + files[path] = files.get(path, b"")[:request["offset"]] + base64.b64decode(request["data"]) + elif operation == "commit": + files[request["destination"]] = files.pop(path) + elif operation == "read": + data = files[path][request["offset"]:request["offset"] + request["length"]] + return {"data": base64.b64encode(data).decode()} + elif operation == "remove": + files.pop(path, None) + return {} + + +class Client(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.temporary = tempfile.TemporaryDirectory(prefix="computer-client-") + data = Path(cls.temporary.name).resolve() + proof = os.urandom(32).hex() + (data / "proof").write_text(proof) + with socket.socket() as available: + available.bind(("127.0.0.1", 0)) + port = available.getsockname()[1] + host = socketserver.ThreadingUnixStreamServer(str(data / "host.sock"), Host) + threading.Thread(target=host.serve_forever, daemon=True).start() + environment = {**os.environ, "SNOWGLOBE_DOMAIN": "paperclover.net", "SNOWGLOBE_DATA_DIR": str(data), + "SNOWGLOBE_PUBLIC_ORIGIN": "https://" + HOST, "SNOWGLOBE_AUTH_RP_ID": "auth.paperclover.net", + "SNOWGLOBE_FILE_ORIGIN": "https://file.paperclover.net", "SNOWGLOBE_AUTH_REQUIRED": "1", + "SNOWGLOBE_WEB_DIR": str(Path("dashboard/dist").resolve()), "PORT": str(port), + "SNOWGLOBE_PROXY_TOKEN_FILE": str(data / "proof"), "SNOWGLOBE_HOST_SOCKET": str(data / "host.sock")} + account = json.loads(subprocess.run([BINARY, "--preview-account"], env=environment, check=True, + capture_output=True, text=True).stdout) + with sqlite3.connect(data / "accounts.sqlite") as db: + Host.owner = db.execute("SELECT id FROM users WHERE username='preview'").fetchone()[0] + cls.log = data / "server.log" + cls.server = subprocess.Popen([BINARY], env=environment, stdout=cls.log.open("wb"), stderr=subprocess.STDOUT) + deadline = time.monotonic() + 30 + while True: + try: + socket.create_connection(("127.0.0.1", port), timeout=0.1).close() + break + except OSError: + assert cls.server.poll() is None and time.monotonic() < deadline, cls.log.read_text()[-2000:] + time.sleep(0.05) + cls.headers = {"Host": HOST, "Snowglobe-Proxy-Token": proof, "X-Snowglobe-Client-IP": "127.0.0.1"} + cls.port = port + real = computer.urlopen + + def local(request, timeout=None): + request = Request(request) if isinstance(request, str) else request + url = urlsplit(request.full_url) + assert url.netloc == HOST, request.full_url + request.full_url = f"http://127.0.0.1:{port}{url.path}" + (f"?{url.query}" if url.query else "") + for key, value in cls.headers.items(): + request.add_header(key, value) + return real(request, timeout=timeout) + + computer.urlopen = local + computer.ORIGIN, computer.RESOURCE = f"https://{HOST}/", f"https://{HOST}/mcp/computer" + computer.STATE = data / "client/state.json" + cls.cookies = {} + csrf = cls.request("/auth/status")["csrf"] + cls.request("/auth/password", "POST", {"csrf": csrf, "username": account["username"], + "password": account["password"], "next": "/"}) + + @classmethod + def tearDownClass(cls): + cls.server.terminate() + cls.server.wait(timeout=10) + cls.temporary.cleanup() + + @classmethod + def request(cls, path, method="GET", body=None): + headers = {**cls.headers, "Cookie": "; ".join(f"{k}={v}" for k, v in cls.cookies.items())} + if body is not None: + headers.update({"Origin": "https://" + HOST, "Content-Type": "application/json"}) + connection = http.client.HTTPConnection("127.0.0.1", cls.port, timeout=30) + connection.request(method, path, json.dumps(body) if body is not None else None, headers) + response = connection.getresponse() + content = response.read() + for cookie in response.headers.get_all("set-cookie") or []: + key, value = cookie.split(";", 1)[0].split("=", 1) + cls.cookies[key] = value + assert response.status in (200, 302), (path, response.status, content[:300]) + return response.headers["location"] if response.status == 302 else json.loads(content) + + def connect(self): + link = urlsplit(computer.login()) + pending = self.request(f"{link.path}?{link.query}").removeprefix("/connect/") + self.assertEqual(self.request(f"/api/mcp/consent/{pending}")["scopes"], computer.SCOPES.split()) + return self.request(f"/api/mcp/consent/{pending}", "POST", {"resources": ["test-vm"]})["redirect"] + + def test_end_to_end(self): + with self.assertRaisesRegex(computer.ComputerError, "login"): + computer.Computer().call("computer_list") + redirected = self.connect() + with self.assertRaisesRegex(computer.ComputerError, "different login"): + computer.login(redirected.replace("state=", "state=x")) + redirected = self.connect() + self.assertIsNone(computer.login(redirected)) + self.assertEqual(computer.STATE.stat().st_mode & 0o777, 0o600) + + vm = computer.Computer() + self.assertIn("computer_exec", {tool["name"] for tool in vm.tools()}) + self.assertEqual([c["id"] for c in vm.call("computer_list")["computers"]], ["test-vm"]) + ran = vm.call("computer_exec", vm="test-vm", script="uname") + self.assertEqual((ran["stdout"], ran["png"]), ("ran uname", base64.b64decode(PNG))) + with self.assertRaisesRegex(computer.ComputerError, "granted"): + vm.call("computer_shot", vm="other-vm") + + source = Path(self.temporary.name) / "payload.bin" + source.write_bytes(os.urandom(200_000)) + self.assertEqual(vm.upload("test-vm", source, "/tmp/payload.bin")["bytes"], 200_000) + vm.download("test-vm", "/tmp/payload.bin", source.with_suffix(".back")) + self.assertEqual(source.with_suffix(".back").read_bytes(), source.read_bytes()) + + self.assertIn("png", vm.call("computer_shot", vm="test-vm")) + + state = json.loads(computer.STATE.read_text()) + computer.STATE.write_text(json.dumps({**state, "access_token": "x" * 43})) + self.assertTrue(computer.Computer().call("computer_list")["computers"]) + + # Concurrent renewals must not replay a refresh token, which would revoke the connection. + state = json.loads(computer.STATE.read_text()) + computer.STATE.write_text(json.dumps({**state, "expires_at": 0})) + results = [] + threads = [threading.Thread(target=lambda: results.append(computer.Computer().call("computer_list"))) + for _ in range(6)] + for thread in threads: + thread.start() + for thread in threads: + thread.join() + self.assertEqual(len(results), 6) + self.assertNotEqual(json.loads(computer.STATE.read_text())["refresh_token"], state["refresh_token"]) + self.assertTrue(computer.Computer().call("computer_list")["computers"]) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--binary", type=Path, default=Path("dashboard/target/debug/home-dashboard")) + args, rest = parser.parse_known_args() + BINARY = str(args.binary.resolve()) + unittest.main(argv=[sys.argv[0], *rest]) diff --git a/tools/computer.py b/tools/computer.py new file mode 100644 index 0000000000000000000000000000000000000000..6a488c953e6cf51ff2db13e71251b859a0fd053b --- /dev/null +++ b/tools/computer.py @@ -0,0 +1,238 @@ +#!/usr/bin/env python3 +"""Script Snow Globe's VMs through the Computer MCP, using only the standard library. + +Connect once; approve the VMs this script may use in your browser: + + python3 computer.py login # prints a link to open + python3 computer.py login 'http://127.0.0.1:9/callback?code=…' + +The approval page redirects to an address that does not load. Copy that +address from the browser into the second command. The connection renews +itself while used at least once every 30 days; manage or revoke it in the +dashboard's MCP settings. + + python3 computer.py tools # tool names and descriptions + python3 computer.py call computer_list + python3 computer.py call computer_exec '{"vm": "m3-devbox", "script": "sw_vers"}' --png after.png + python3 computer.py upload m3-devbox ./app.zip /tmp/app.zip + python3 computer.py download m3-devbox /tmp/log.txt ./log.txt + +From Python: + + from computer import Computer + vm = Computer() + print(vm.call("computer_list")) + shot = vm.call("computer_shot", vm="m3-devbox")["png"] # PNG bytes + vm.call("computer_input", vm="m3-devbox", screenshot=False, + actions=[{"type": "click", "x": 400, "y": 300}]) + +`call` returns the tool's JSON result. A screenshot that comes with it, as +`computer_exec`, `computer_input` and `computer_ui_action` send by default, +appears as PNG bytes under "png". Failures raise `ComputerError`. +""" +import argparse +import base64 +import fcntl +import hashlib +import json +import os +import secrets +import shutil +import socket +import sys +import time +from pathlib import Path +from urllib.error import HTTPError +from urllib.parse import parse_qs, urlencode, urlsplit +from urllib.request import Request, urlopen + +ORIGIN = "https://snowglobe.paperclover.net/" +RESOURCE = ORIGIN + "mcp/computer" +REDIRECT = "http://127.0.0.1:9/callback" +SCOPES = "computer:read computer:control computer:create offline_access" +STATE = Path.home() / ".config/computer-mcp/state.json" + + +class ComputerError(Exception): + pass + + +def _http(url, data=None, headers=(), method=None): + """Return (status, body) without raising on HTTP error statuses.""" + request = Request(url, data=data, headers=dict(headers), method=method) + try: + with urlopen(request, timeout=900) as response: + return response.status, response.read() + except HTTPError as error: + return error.code, error.read() + + +def _form(path, fields): + status, body = _http(ORIGIN + path, urlencode(fields).encode(), + {"Content-Type": "application/x-www-form-urlencoded"}) + if status != 200: + raise ComputerError(f"{path}: HTTP {status} {body[:200].decode(errors='replace')}") + return json.loads(body) + + +class _State: + """The token file, locked so concurrent scripts never replay a rotated refresh token.""" + + def __enter__(self): + STATE.parent.mkdir(mode=0o700, parents=True, exist_ok=True) + self.lock = open(STATE.with_suffix(".lock"), "a") + fcntl.flock(self.lock, fcntl.LOCK_EX) + self.value = json.loads(STATE.read_text()) if STATE.exists() else {} + return self + + def save(self): + partial = STATE.with_suffix(".partial") + partial.write_text(json.dumps(self.value)) + partial.chmod(0o600) + partial.replace(STATE) + + def keep(self, tokens): + self.value.update(access_token=tokens["access_token"], refresh_token=tokens["refresh_token"], + expires_at=time.time() + tokens["expires_in"] - 60) + self.save() + + def __exit__(self, *_): + self.lock.close() + + +def login(redirected=None): + """Without an address, print the approval link; with one, finish connecting.""" + with _State() as state: + if redirected is None: + if "client_id" not in state.value: + status, body = _http(ORIGIN + "oauth/register", json.dumps({ + "client_name": f"computer.py on {socket.gethostname()}", "redirect_uris": [REDIRECT], + "token_endpoint_auth_method": "none"}).encode(), {"Content-Type": "application/json"}) + if status != 201: + raise ComputerError(f"Registration failed: {body[:200]!r}") + state.value["client_id"] = json.loads(body)["client_id"] + verifier, nonce = secrets.token_urlsafe(48), secrets.token_urlsafe(16) + state.value["pending"] = {"verifier": verifier, "state": nonce} + state.save() + challenge = base64.urlsafe_b64encode(hashlib.sha256(verifier.encode()).digest()).rstrip(b"=").decode() + return ORIGIN + "oauth/authorize?" + urlencode({ + "response_type": "code", "client_id": state.value["client_id"], "redirect_uri": REDIRECT, + "scope": SCOPES, "state": nonce, "resource": RESOURCE, + "code_challenge": challenge, "code_challenge_method": "S256"}) + pending = state.value.pop("pending", None) + query = {key: values[0] for key, values in parse_qs(urlsplit(redirected).query).items()} + if pending is None or query.get("state") != pending["state"]: + raise ComputerError("That address belongs to a different login. Run `computer.py login` again.") + if "code" not in query: + raise ComputerError(f"The approval was not granted: {query.get('error', 'no code')}.") + state.keep(_form("oauth/token", { + "grant_type": "authorization_code", "code": query["code"], "code_verifier": pending["verifier"], + "redirect_uri": REDIRECT, "client_id": state.value["client_id"], "resource": RESOURCE})) + + +class Computer: + def __init__(self): + self._token = None + + def _access(self, rejected=None): + """Return a current access token, renewing it if expired or just rejected.""" + with _State() as state: + value = state.value + if "refresh_token" not in value: + raise ComputerError("Not connected. Run `computer.py login` first.") + if value["access_token"] == rejected or value["expires_at"] <= time.time(): + try: + state.keep(_form("oauth/token", {"grant_type": "refresh_token", "client_id": value["client_id"], + "refresh_token": value["refresh_token"], "resource": RESOURCE})) + except ComputerError as error: + raise ComputerError(f"The connection ended ({error}). Run `computer.py login` again.") from None + return value["access_token"] + + def _rpc(self, method, params): + message = json.dumps({"jsonrpc": "2.0", "id": 1, "method": method, "params": params}).encode() + self._token = self._token or self._access() + for retry in (True, False): + status, body = _http(RESOURCE, message, {"Authorization": "Bearer " + self._token, + "Content-Type": "application/json", + "Accept": "application/json, text/event-stream"}) + if status != 401 or not retry: + break + self._token = self._access(rejected=self._token) + if status != 200: + raise ComputerError(f"HTTP {status}: {body[:300].decode(errors='replace')}") + reply = json.loads(body) + if "error" in reply: + raise ComputerError(reply["error"]["message"]) + return reply["result"] + + def tools(self): + return self._rpc("tools/list", {})["tools"] + + def call(self, tool, **arguments): + result = self._rpc("tools/call", {"name": tool, "arguments": arguments}) + text = next(block["text"] for block in result["content"] if block["type"] == "text") + if result.get("isError"): + raise ComputerError(text) + value = json.loads(text) + for block in result["content"]: + if block["type"] == "image": + value["png"] = base64.b64decode(block["data"]) + return value + + def upload(self, vm, local, remote, overwrite=False): + size = os.path.getsize(local) + ticket = self.call("computer_upload", vm=vm, path=remote, size=size, overwrite=overwrite) + with open(local, "rb") as file: + status, body = _http(ticket["url"], file, {"Content-Length": str(size)}, "PUT") + if status != 200: + raise ComputerError(f"Upload failed: {body[:300].decode(errors='replace')}") + return json.loads(body) + + def download(self, vm, remote, local): + ticket = self.call("computer_download", vm=vm, path=remote) + try: + with urlopen(ticket["url"], timeout=900) as response, open(local, "wb") as file: + shutil.copyfileobj(response, file) + except HTTPError as error: + raise ComputerError(f"Download failed: {error.read()[:300].decode(errors='replace')}") from None + + +def main(): + parser = argparse.ArgumentParser(description=__doc__.splitlines()[0]) + commands = parser.add_subparsers(dest="command", required=True) + commands.add_parser("login").add_argument("redirected", nargs="?") + commands.add_parser("tools") + call = commands.add_parser("call") + call.add_argument("tool") + call.add_argument("arguments", nargs="?", default="{}", help="JSON object") + call.add_argument("--png", help="save a returned screenshot here") + for name, fields in [("upload", ["vm", "local", "remote"]), ("download", ["vm", "remote", "local"])]: + command = commands.add_parser(name) + for field in fields: + command.add_argument(field) + commands.choices["upload"].add_argument("--overwrite", action="store_true") + args = parser.parse_args() + try: + if args.command == "login": + link = login(args.redirected) + print(f"Open this link and approve:\n\n{link}\n\nThen run: computer.py login '
'" + if link else "Connected.") + elif args.command == "tools": + for tool in Computer().tools(): + print(f"{tool['name']}: {tool.get('description', '')}") + elif args.command == "call": + value = Computer().call(args.tool, **json.loads(args.arguments)) + png = value.pop("png", None) if isinstance(value, dict) else None + if png and args.png: + Path(args.png).write_bytes(png) + print(json.dumps(value, indent=2)) + elif args.command == "upload": + print(json.dumps(Computer().upload(args.vm, args.local, args.remote, args.overwrite))) + else: + Computer().download(args.vm, args.remote, args.local) + except ComputerError as error: + sys.exit(f"computer.py: {error}") + + +if __name__ == "__main__": + main()