sid-harness 0.3.0__py3-none-any.whl

sid_harness/brave_proof.py

@@ -0,0 +1,246 @@
+"""Live Brave proof: pair -> grant write -> run -> review diff -> apply to disk.
+
+This drives the real protocol from a page executed by the installed Brave
+browser (headless), against a real loopback bridge. The model call is stubbed
+only because a proof must not spend a customer's SID key; everything else —
+origin allowlist, pairing code exchange, explicit write grant, proposal digest,
+denylist validation, atomic write, receipt — is the production path.
+
+Run ``python -m sid_harness.brave_proof`` or ``install/prove_brave_apply.py``.
+Exit 0 on a real applied write. Exit 2 when Brave is not installed (honest
+skip), 1 on any failure.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import threading
+import time
+import urllib.parse
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+
+from . import bridge as bridge_mod
+
+BRAVE_CANDIDATES = (
+    r"C:\Program Files\BraveSoftware\Brave-Browser\Application\brave.exe",
+    r"C:\Program Files (x86)\BraveSoftware\Brave-Browser\Application\brave.exe",
+    os.path.expandvars(r"%LOCALAPPDATA%\BraveSoftware\Brave-Browser\Application\brave.exe"),
+)
+
+
+def find_brave() -> str | None:
+    for candidate in BRAVE_CANDIDATES:
+        if candidate and Path(candidate).is_file():
+            return candidate
+    found = shutil.which("brave-browser") or shutil.which("brave") or shutil.which("brave.exe")
+    return found
+
+
+PAGE = """<!doctype html>
+<meta charset="utf-8">
+<title>SID bridge Brave proof</title>
+<body>
+<pre id="log">starting</pre>
+<script>
+const q = new URLSearchParams(location.search);
+const bridge = q.get("bridge");
+const code = q.get("code");
+const log = (s) => { document.getElementById("log").textContent += "\\n" + s; };
+async function jpost(path, body, headers) {
+  const resp = await fetch(bridge + path, {
+    method: "POST",
+    headers: Object.assign({ "Content-Type": "application/json" }, headers || {}),
+    body: JSON.stringify(body || {}),
+  });
+  let data = {};
+  try { data = await resp.json(); } catch (_) {}
+  if (!resp.ok) throw new Error(path + " HTTP " + resp.status + " " + (data.error || ""));
+  return data;
+}
+(async () => {
+  try {
+    log("pair");
+    const pair = await jpost("/pair", { code: code });
+    const auth = { "X-SID-Bridge-Token": pair.token };
+    log("grant");
+    await jpost("/grant-write", { granted: true, confirm: "enable-write" }, auth);
+    log("run");
+    const run = await jpost("/run", { task: "update index.html" }, Object.assign({
+      "X-SID-Api-Key": "proof-key",
+    }, auth));
+    if (!run.proposal) throw new Error("no proposal returned");
+    log("review " + run.proposal.digest);
+    const applied = await jpost("/apply", {
+      proposal_id: run.proposal.id,
+      digest: run.proposal.digest,
+    }, auth);
+    log("applied " + applied.written.join(","));
+    await fetch("/done?written=" + encodeURIComponent(applied.written.join(",")) +
+                "&digest=" + encodeURIComponent(run.proposal.digest));
+  } catch (e) {
+    log("error " + e.message);
+    await fetch("/fail?msg=" + encodeURIComponent(e.message || String(e)));
+  }
+})();
+</script>
+"""
+
+
+class _PageHandler(BaseHTTPRequestHandler):
+    def log_message(self, fmt, *args):
+        pass
+
+    def do_GET(self):  # noqa: N802
+        parsed = urllib.parse.urlparse(self.path)
+        if parsed.path == "/":
+            body = PAGE.encode("utf-8")
+            self.send_response(200)
+            self.send_header("Content-Type", "text/html; charset=utf-8")
+            self.send_header("Content-Length", str(len(body)))
+            self.end_headers()
+            self.wfile.write(body)
+            return
+        if parsed.path in ("/done", "/fail"):
+            params = urllib.parse.parse_qs(parsed.query)
+            payload = {key: values[0] for key, values in params.items()}
+            self.server.proof_result = {"ok": parsed.path == "/done", **payload}  # type: ignore[attr-defined]
+            self.server.proof_event.set()  # type: ignore[attr-defined]
+            self.send_response(204)
+            self.end_headers()
+            return
+        self.send_response(404)
+        self.end_headers()
+
+
+def _fake_run_task(*, directory, task, api_key, base_url=None, model="auto", test_argv=None):
+    return {
+        "final_response": "Updated index.html after reading the real tree.",
+        "model": "proof-stub",
+        "steps": 2,
+        "tool_calls": 1,
+        "changed": ["index.html"],
+        "readback": {"index.html": "<h1>changed by SID through Brave</h1>\n"},
+        "diff": "--- a/index.html\n+++ b/index.html\n@@\n-<h1>hello</h1>\n+<h1>changed by SID through Brave</h1>\n",
+        "test": {"executed": False, "passed": None},
+    }
+
+
+def run_proof(*, timeout: float = 45.0) -> dict:
+    brave = find_brave()
+    if not brave:
+        return {"ok": False, "skipped": True, "error": "Brave is not installed"}
+
+    tmp = Path(tempfile.mkdtemp(prefix="sid-brave-proof-"))
+    workspace = tmp / "workspace"
+    workspace.mkdir()
+    (workspace / "index.html").write_text("<h1>hello</h1>\n", encoding="utf-8")
+    (workspace / "app.js").write_text("console.log('hello')\n", encoding="utf-8")
+
+    page_server = ThreadingHTTPServer(("127.0.0.1", 0), _PageHandler)
+    page_server.daemon_threads = True
+    page_server.proof_event = threading.Event()  # type: ignore[attr-defined]
+    page_server.proof_result = None  # type: ignore[attr-defined]
+    page_thread = threading.Thread(target=page_server.serve_forever, daemon=True)
+    page_thread.start()
+    page_origin = f"http://127.0.0.1:{page_server.server_address[1]}"
+
+    original_run_task = bridge_mod.run_task
+    bridge_mod.run_task = _fake_run_task  # type: ignore[assignment]
+    httpd = bridge_mod.serve(
+        workspace,
+        port=0,
+        token="proof-token",
+        write_capable=True,
+        pair_code="proof-pair-code",
+        pair_ttl=300,
+        state_dir=tmp / "state",
+        allowed_origins=(page_origin,),
+    )
+    bridge_thread = threading.Thread(target=httpd.serve_forever, daemon=True)
+    bridge_thread.start()
+    bridge_url = f"http://127.0.0.1:{httpd.server_address[1]}"
+
+    profile = tmp / "brave-profile"
+    url = (
+        f"{page_origin}/?"
+        + urllib.parse.urlencode({"bridge": bridge_url, "code": "proof-pair-code"})
+    )
+    args = [
+        brave,
+        "--headless=new",
+        "--disable-gpu",
+        "--no-first-run",
+        "--no-default-browser-check",
+        "--disable-background-networking",
+        "--disable-sync",
+        "--no-proxy-server",
+        f"--user-data-dir={profile}",
+        url,
+    ]
+    proc = None
+    try:
+        proc = subprocess.Popen(args, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        page_server.proof_event.wait(timeout)  # type: ignore[attr-defined]
+        result = dict(page_server.proof_result or {})  # type: ignore[attr-defined]
+    finally:
+        if proc is not None:
+            try:
+                proc.terminate()
+                proc.wait(timeout=10)
+            except Exception:
+                try:
+                    proc.kill()
+                except Exception:
+                    pass
+        httpd.shutdown()
+        httpd.server_close()
+        page_server.shutdown()
+        page_server.server_close()
+        bridge_mod.run_task = original_run_task  # type: ignore[assignment]
+
+    if not result:
+        return {"ok": False, "error": f"Brave did not finish the flow within {timeout:g}s"}
+    disk = (workspace / "index.html").read_text(encoding="utf-8")
+    receipts = sorted((tmp / "state" / "receipts").glob("apply_*.json"))
+    result.update({
+        "brave": brave,
+        "bridge": bridge_url,
+        "origin": page_origin,
+        "disk": disk,
+        "receipts": [str(path) for path in receipts],
+        "receipt": json.loads(receipts[-1].read_text(encoding="utf-8")) if receipts else None,
+    })
+    result["ok"] = bool(
+        result.get("ok")
+        and "changed by SID through Brave" in disk
+        and receipts
+    )
+    return result
+
+
+def main(argv: list[str] | None = None) -> int:
+    import argparse
+
+    ap = argparse.ArgumentParser(description="Prove the Brave end-to-end apply path live.")
+    ap.add_argument("--timeout", type=float, default=45.0)
+    args = ap.parse_args(argv)
+    result = run_proof(timeout=args.timeout)
+    if result.get("skipped"):
+        print(f"brave_proof: SKIP — {result.get('error')}")
+        return 2
+    print(json.dumps(result, indent=2, sort_keys=True))
+    if result.get("ok"):
+        print("brave_proof: PASS — Brave applied the reviewed diff to disk")
+        return 0
+    print(f"brave_proof: FAIL — {result.get('error', 'unknown failure')}")
+    return 1
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())