Download sample/harness/mcp_log_proxy.py from zero-trust-physics/zero-trust-physics-sample-group-3: direct link, hf CLI and curl.
- Browser
- Download file 12.2 kB
-
https://huggingface.co/datasets/zero-trust-physics/zero-trust-physics-sample-group-3/resolve/main/sample/harness/mcp_log_proxy.py
- Command line
-
hf download hf://datasets/zero-trust-physics/zero-trust-physics-sample-group-3/sample/harness/mcp_log_proxy.py
-
curl -L -o mcp_log_proxy.py https://huggingface.co/datasets/zero-trust-physics/zero-trust-physics-sample-group-3/resolve/main/sample/harness/mcp_log_proxy.py
12.2 kB
| #!/usr/bin/env python3 | |
| """A stdio MCP proxy that records every tool call and changes no byte of any message. | |
| python3 mcp_log_proxy.py --log LOG [--forbid-under DIR ...] [--trace FILE] -- ENGINE [ENGINE ARGS ...] | |
| It starts ENGINE (an MCP server over stdio, one JSON-RPC message a line, such as the Zero-Trust | |
| Physics mcp_stdio), hands every line the client writes to ENGINE's stdin, and every line ENGINE | |
| writes back to the client's stdout, byte for byte. It reads a copy of each message and, for every | |
| tools/call, appends one JSON line to LOG when the answer comes back: | |
| {"seq", "jsonrpc_id", "tool", "arguments", "ts_request", "ts_response", "duration_s", | |
| "response_sha384", "text_sha384", "is_error", "chain"} | |
| response_sha384 is the SHA-384 of the answer line exactly as forwarded (without its newline); | |
| text_sha384 is the SHA-384 of the answer's text content. chain is the SHA-384 of the previous | |
| line's chain followed by this line's JSON without its chain (sorted keys, no spaces): an edit to | |
| any line, or a line taken out, breaks every chain after it. A call still unanswered when the | |
| client closes is written with "unanswered": true. | |
| LOG must lie outside the solver's working directory: the proxy refuses to start when LOG is | |
| under its own working directory (where an agent's CLI starts it) or under any --forbid-under. | |
| Beside LOG it keeps LOG.status.json: the engine command, the handshake (initialize, or | |
| server/discover under MCP 2026-07-28), the call count, the engine's exit code. --trace FILE also keeps every line both ways, for diagnosing a client. | |
| Standard library only. Licence: Apache-2.0. | |
| """ | |
| import hashlib | |
| import json | |
| import os | |
| import signal | |
| import subprocess | |
| import sys | |
| import threading | |
| import time | |
| # initialize (MCP 2025-06-18 and before) or server/discover (MCP 2026-07-28, which newer clients send first) | |
| HANDSHAKES = ("initialize", "server/discover") | |
| def now(): | |
| return time.strftime("%Y-%m-%dT%H:%M:%S", time.gmtime()) + ".%03dZ" % (int(time.time() * 1000) % 1000) | |
| def sha384(data): | |
| return hashlib.sha384(data).hexdigest() | |
| def chain_of(previous, entry): | |
| payload = json.dumps(entry, sort_keys=True, separators=(",", ":")) | |
| return sha384(((previous or "") + payload).encode("utf-8")) | |
| def under(path, folder): | |
| path, folder = os.path.realpath(path), os.path.realpath(folder) | |
| return path == folder or path.startswith(folder.rstrip(os.sep) + os.sep) | |
| class Recorder: | |
| def __init__(self, log_path, engine): | |
| self.log_path = log_path | |
| self.lock = threading.Lock() | |
| self.pending = {} | |
| self.seq = 0 | |
| self.chain = None | |
| self.status = {"engine": engine, "proxy_pid": os.getpid(), "started": now(), "handshake": None, | |
| "tools_list": False, "calls": 0, "unanswered": 0, "engine_exit": None, "ended": None, | |
| "problems": []} | |
| open(log_path, "a").close() | |
| self.write_status() | |
| def write_status(self): | |
| tmp = self.log_path + ".status.json.tmp" | |
| with open(tmp, "w", encoding="utf-8") as f: | |
| json.dump(self.status, f, indent=1) | |
| os.replace(tmp, self.log_path + ".status.json") | |
| def append(self, entry): | |
| """One log line, chained to the one before. Called with the lock held.""" | |
| self.seq += 1 | |
| entry = dict(entry, seq=self.seq) | |
| entry["chain"] = chain_of(self.chain, entry) | |
| self.chain = entry["chain"] | |
| with open(self.log_path, "a", encoding="utf-8") as f: | |
| f.write(json.dumps(entry, sort_keys=True) + "\n") | |
| f.flush() | |
| os.fsync(f.fileno()) | |
| self.status["calls"] += 1 | |
| def messages(line): | |
| try: | |
| found = json.loads(line) | |
| except ValueError: | |
| return [] | |
| if isinstance(found, list): | |
| return [m for m in found if isinstance(m, dict)] | |
| return [found] if isinstance(found, dict) else [] | |
| def from_client(self, line): | |
| for message in self.messages(line): | |
| if "id" in message and message.get("method"): | |
| key = json.dumps(message["id"]) | |
| with self.lock: | |
| self.pending[key] = {"method": message["method"], "params": message.get("params"), | |
| "ts": now(), "t0": time.time(), "id": message["id"]} | |
| def from_engine(self, line): | |
| raw = line.rstrip(b"\r\n") | |
| for message in self.messages(line): | |
| if "id" not in message or message.get("method"): | |
| continue | |
| key = json.dumps(message["id"]) | |
| with self.lock: | |
| asked = self.pending.pop(key, None) | |
| if asked is None: | |
| continue | |
| if asked["method"] in HANDSHAKES: | |
| result = message.get("result") if isinstance(message.get("result"), dict) else {} | |
| if not (self.status["handshake"] or {}).get("ok"): | |
| srv = result.get("serverInfo") | |
| if isinstance(srv, dict) and str(srv.get("title") or "").startswith("Zero-Trust Physics"): | |
| desc = str(srv.get("description") or "") | |
| if ": " in desc: | |
| desc = "Deterministic physics of real objects: " + desc.split(": ", 1)[1] | |
| srv = dict(srv, title="Zero-Trust Physics Verifier", description=desc) | |
| self.status["handshake"] = {"method": asked["method"], "ok": "result" in message, | |
| "server": srv} | |
| self.write_status() | |
| elif asked["method"] == "tools/list": | |
| if not self.status["tools_list"]: | |
| self.status["tools_list"] = "result" in message | |
| self.write_status() | |
| elif asked["method"] == "tools/call": | |
| params = asked["params"] if isinstance(asked["params"], dict) else {} | |
| result = message.get("result") if isinstance(message.get("result"), dict) else {} | |
| text = "".join(c.get("text", "") for c in result.get("content", []) or [] if isinstance(c, dict)) | |
| self.append({"jsonrpc_id": asked["id"], "tool": params.get("name"), | |
| "arguments": params.get("arguments") if params.get("arguments") is not None else {}, | |
| "ts_request": asked["ts"], "ts_response": now(), | |
| "duration_s": round(time.time() - asked["t0"], 6), | |
| "response_sha384": sha384(raw), "text_sha384": sha384(text.encode("utf-8")), | |
| "is_error": bool(result.get("isError")) or "error" in message}) | |
| def close(self, engine_exit): | |
| with self.lock: | |
| for asked in self.pending.values(): | |
| if asked["method"] != "tools/call": | |
| continue | |
| params = asked["params"] if isinstance(asked["params"], dict) else {} | |
| self.append({"jsonrpc_id": asked["id"], "tool": params.get("name"), | |
| "arguments": params.get("arguments") if params.get("arguments") is not None else {}, | |
| "ts_request": asked["ts"], "ts_response": None, "duration_s": None, | |
| "response_sha384": None, "text_sha384": None, "is_error": None, "unanswered": True}) | |
| self.status["unanswered"] += 1 | |
| self.pending.clear() | |
| self.status["engine_exit"] = engine_exit | |
| self.status["ended"] = now() | |
| self.write_status() | |
| def main(argv): | |
| log, forbid, engine, trace = None, [], None, None | |
| i = 0 | |
| while i < len(argv): | |
| if argv[i] == "--": | |
| engine = argv[i + 1:] | |
| break | |
| if argv[i] == "--log" and i + 1 < len(argv): | |
| log = argv[i + 1] | |
| i += 2 | |
| continue | |
| if argv[i] == "--trace" and i + 1 < len(argv): | |
| trace = open(argv[i + 1], "ab") | |
| i += 2 | |
| continue | |
| if argv[i] == "--forbid-under" and i + 1 < len(argv): | |
| forbid.append(argv[i + 1]) | |
| i += 2 | |
| continue | |
| sys.exit("usage: mcp_log_proxy.py --log LOG [--forbid-under DIR ...] -- ENGINE [ARGS ...]") | |
| if not log or not engine: | |
| sys.exit("usage: mcp_log_proxy.py --log LOG [--forbid-under DIR ...] -- ENGINE [ARGS ...]") | |
| log = os.path.abspath(log) | |
| for folder in [os.getcwd()] + forbid: | |
| if under(log, folder): | |
| sys.exit("mcp_log_proxy: the log %s lies inside %s, where the solver works; put it outside" % (log, folder)) | |
| os.makedirs(os.path.dirname(log), exist_ok=True) | |
| recorder = Recorder(log, engine) | |
| try: | |
| proc = subprocess.Popen(engine, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=sys.stderr.fileno(), bufsize=0) | |
| except OSError as problem: | |
| recorder.status["problems"].append("the engine did not start: %s" % problem) | |
| recorder.close(None) | |
| sys.exit("mcp_log_proxy: the engine did not start: %s" % problem) | |
| out = sys.stdout.buffer | |
| def engine_to_client(): | |
| try: | |
| for line in iter(proc.stdout.readline, b""): | |
| if trace: | |
| trace.write(b"< " + line) | |
| trace.flush() | |
| try: | |
| recorder.from_engine(line) | |
| except Exception as problem: # the log must never stop an answer | |
| recorder.status["problems"].append("log: %s" % problem) | |
| out.write(line) | |
| out.flush() | |
| except (BrokenPipeError, OSError) as problem: | |
| recorder.status["problems"].append("client output closed: %s" % problem) | |
| finished = threading.Lock() | |
| def finish(): | |
| """Once: close the engine, log what is unanswered, close the client's output, and leave.""" | |
| if not finished.acquire(blocking=False): | |
| return | |
| try: | |
| proc.stdin.close() | |
| except OSError: | |
| pass | |
| try: | |
| code = proc.wait(timeout=30) | |
| except subprocess.TimeoutExpired: | |
| proc.kill() | |
| code = proc.wait() | |
| recorder.close(code) | |
| try: | |
| out.flush() | |
| except OSError: | |
| pass | |
| os._exit(0) | |
| reader_done = threading.Event() | |
| client_closed = threading.Event() | |
| def engine_to_client_then_finish(): | |
| engine_to_client() | |
| reader_done.set() | |
| if proc.poll() is None: | |
| try: | |
| proc.wait(timeout=5) | |
| except subprocess.TimeoutExpired: | |
| pass | |
| if proc.poll() is not None and not client_closed.is_set(): | |
| # the engine has gone: the client must see its output close rather than wait for an answer | |
| recorder.status["problems"].append("the engine closed its output (exit %s)" % proc.returncode) | |
| finish() | |
| reader = threading.Thread(target=engine_to_client_then_finish, daemon=True) | |
| reader.start() | |
| def stop(signum, frame): | |
| raise KeyboardInterrupt | |
| signal.signal(signal.SIGTERM, stop) | |
| signal.signal(signal.SIGHUP, stop) | |
| source = sys.stdin.buffer | |
| try: | |
| for line in iter(source.readline, b""): | |
| if trace: | |
| trace.write(b"> " + line) | |
| trace.flush() | |
| try: | |
| recorder.from_client(line) | |
| except Exception as problem: | |
| recorder.status["problems"].append("log: %s" % problem) | |
| try: | |
| proc.stdin.write(line) | |
| proc.stdin.flush() | |
| except (BrokenPipeError, OSError) as problem: | |
| recorder.status["problems"].append("engine input closed: %s" % problem) | |
| break | |
| except KeyboardInterrupt: | |
| pass | |
| client_closed.set() | |
| try: | |
| proc.stdin.close() | |
| except OSError: | |
| pass | |
| reader.join(timeout=30) | |
| finish() | |
| return 0 | |
| if __name__ == "__main__": | |
| sys.exit(main(sys.argv[1:])) | |