Kevin Veen-BirkenbachandClaude Opus 5.5
afd96fcd72
The PermissionRequest hook posted asks cut to the hub's field limits, so a signature covered less than Claude Code would run; it now posts nothing it cannot sign in full and leaves the decision to Claude Code with a reason on stderr. fields.seconds names the field the caller used in its error. Serving a stored page maps an OSError to 500 instead of a dropped connection. The natural-language line marks the register as seen before it builds the inbox, like the page does. do_POST runs every header guard (host, origin, client, content type, MCP) before it reads the body, so a refused request never costs its upload. The runner's reader closes stdout at EOF, because a close from the executing thread blocked on the buffer lock and could SIGPIPE a command still running. The page title counts only inbox items that are not snoozed. Committed on the operator's word despite the gate: cost and time are estimates under 98 % other load and include eight new test cases. 🎯 Fix: 88 % 💥 Break: 3 % 💸 Cost: 106 % ⏱️ Time: 113 % 🛡️ Security: 100 % 🏆 Score: 71 🚦 Gate: ⛔ fix 88 % < 90; cost 106 % > 100, time 113 % > 100: ask the operator before the commit ``` /home/kevinveenbirkenbach/Repositories/github.com/kevinveenbirkenbach/skills/.worktrees/feature/kvb-hub ``` Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
125 lines
8.7 KiB
Python
125 lines
8.7 KiB
Python
from __future__ import annotations
|
|
|
|
import dataclasses
|
|
import json
|
|
import time
|
|
import unittest
|
|
from unittest import mock
|
|
|
|
from hub_case import HubCase
|
|
from hub_support import ASK, PAGE, TREE, key, signing
|
|
from kvb_hub import batches
|
|
|
|
|
|
class TestHubInbox(HubCase):
|
|
def test_inbox_bulk_approval_waits_for_the_undo_window(self):
|
|
green = self.request("feat: green", "")
|
|
red = self.tool("review_request", {**self.arguments("feat: red", "", self.page("red.html", PAGE)), "gate": "fail"})["structuredContent"]["id"]
|
|
ask_id = self.create_ask(ASK)
|
|
risky = self.create_ask({**ASK, "command": "rm -rf build"})
|
|
decision_id = self.decision("Merge now")
|
|
inbox = {item["id"]: item for item in self.snapshot()["inbox"]}
|
|
self.assertEqual([inbox[key]["green"] for key in (green, red, ask_id, risky, decision_id)], [True, False, True, False, True])
|
|
self.assertEqual(inbox[risky]["warnings"], ["löscht rekursiv"])
|
|
batch = [self.entry("review", green, "", ""), self.entry("ask", ask_id, "", ""), self.entry("decision", decision_id, "Merge now", "")]
|
|
signer = key(-7, "main")
|
|
self.assertEqual(self.approve([self.entry("review", green, "", ""), self.entry("review", red, "", "")], None)[0], 400)
|
|
self.assertEqual(self.approve([self.entry("decision", decision_id, "Later", "")], None)[0], 400)
|
|
self.assertEqual(self.approve([self.entry("review", green, "", ""), self.entry("review", green, "", "")], None)[0], 400)
|
|
self.assertEqual(self.approve([self.entry("review", "0123456789abcdef", "", "")], None)[0], 404)
|
|
self.assertEqual(self.post_json("/api/inbox/approve", {"items": batch, "proof": None}, self.client())[0], 403)
|
|
prepared = self.prepare(batch)
|
|
listed = [signing.item_hash(signing.review_item(green, "/repo/.git", "/repo/.worktrees/feature/x", "feature/x", TREE)), signing.item_hash(signing.ask_item(ask_id, "Bash", "make deploy", "/repo", "s1"))]
|
|
self.assertEqual((prepared["payload"]["items"], prepared["challenge"]), (sorted(listed), signing.challenge(prepared["payload"])))
|
|
unsigned = [self.entry("decision", decision_id, "Merge now", ""), {**self.entry("ask", risky, "", ""), "verb": "reject"}]
|
|
self.assertIsNone(self.prepare(unsigned)["payload"])
|
|
partial = signer.proof(self.prepare(batch[:1])["payload"], self.origin)
|
|
for proof in (None, partial, {"payload": prepared["payload"]}, {"payload": {**prepared["payload"], "expires": int(time.time()) - 1}, "assertion": {}}):
|
|
with self.subTest(proof=str(proof)[:80]):
|
|
self.assertEqual(self.approve(batch, proof)[0], 400)
|
|
self.assertEqual(self.approve(unsigned, partial)[0], 400)
|
|
proof = signer.proof(prepared["payload"], self.origin)
|
|
with mock.patch.object(batches, "UNDO", 0.5):
|
|
status, _, body = self.approve(batch, proof)
|
|
self.assertEqual(status, 202, body)
|
|
first = json.loads(body)
|
|
self.assertNotIn("proof", first)
|
|
self.assertEqual(self.approve([batch[0]], None)[0], 409)
|
|
self.assertTrue(all(item["held"] for item in self.snapshot()["inbox"] if item["id"] in (green, ask_id, decision_id)))
|
|
self.assertEqual(self.call("POST", f"/api/inbox/undo/{first['id']}", b"", self.guard(self.host))[0], 200)
|
|
time.sleep(0.8)
|
|
self.assertEqual((self.status(green), self.ask_status(ask_id, "0"), self.choice(decision_id)), ("pending", "pending", None))
|
|
self.assertIsNone(json.loads(self.get(f"/api/reviews/{green}")[2])["proof"])
|
|
second = json.loads(self.approve(batch, proof)[2])
|
|
self.assertEqual(self.status(green), "pending")
|
|
self.assertIsNone(json.loads(self.get(f"/api/asks/{ask_id}?wait=0")[2])["proof"])
|
|
self.settle(lambda: self.status(green) == "approved")
|
|
self.settle(lambda: self.choice(decision_id) == "Merge now")
|
|
self.assertEqual(self.ask_status(ask_id, "0"), "allowed")
|
|
self.assertEqual(json.loads(self.get(f"/api/asks/{ask_id}?wait=0")[2])["proof"], proof)
|
|
self.assertEqual(json.loads(self.get(f"/api/reviews/{green}")[2])["proof"], proof)
|
|
self.assertNotIn(b'"assertion"', self.get("/api/state")[2])
|
|
self.assertEqual(self.call("POST", f"/api/inbox/undo/{second['id']}", b"", self.guard(self.host))[0], 409)
|
|
self.assertEqual(self.call("POST", "/api/inbox/undo/0123456789abcdef", b"", self.guard(self.host))[0], 404)
|
|
with mock.patch.object(batches, "UNDO", 0.05):
|
|
self.assertEqual(self.approve([self.entry("review", red, "", "")], self.signed([self.entry("review", red, "", "")], signer))[0], 202)
|
|
self.settle(lambda: self.status(red) == "approved")
|
|
until = time.time() + 3600
|
|
self.assertEqual(self.post_json("/api/inbox/mark", {"kind": "ask", "id": risky, "until": until, "pinned": True}, self.guard(self.host))[0], 200)
|
|
top = self.snapshot()["inbox"][0]
|
|
self.assertEqual((top["id"], top["pinned"], round(top["until"])), (risky, True, round(until)))
|
|
for payload in (
|
|
{"kind": "ask", "id": risky, "until": time.time() - 5, "pinned": False},
|
|
{"kind": "ask", "id": risky, "until": time.time() + 9 * 86400, "pinned": False},
|
|
{"kind": "ask", "id": risky, "until": 0, "pinned": "yes"},
|
|
{"kind": "radio", "id": risky, "until": 0, "pinned": False},
|
|
):
|
|
with self.subTest(payload=payload):
|
|
self.assertEqual(self.post_json("/api/inbox/mark", payload, self.guard(self.host))[0], 400)
|
|
titles = [row["title"] for row in self.events("kinds=approval")["events"]]
|
|
self.assertIn("Freigabe review: feat: green", titles)
|
|
self.assertTrue(any(title.startswith("Rückgängig: ") for title in titles))
|
|
|
|
def test_the_sign_endpoint_and_the_page_offer_the_pinned_keys_only(self):
|
|
ask_id = self.create_ask(ASK)
|
|
prepared = self.prepare([self.entry("ask", ask_id, "", "")])
|
|
self.assertEqual((prepared["credentials"], self.snapshot()["approvers"]), ([], []))
|
|
self.assertEqual(prepared["payload"]["items"], [signing.item_hash(signing.ask_item(ask_id, "Bash", "make deploy", "/repo", "s1"))])
|
|
self.assertTrue(time.time() < prepared["payload"]["expires"] <= time.time() + signing.LIFETIME)
|
|
self.assertRegex(prepared["payload"]["nonce"], r"^[0-9a-f]{32}$")
|
|
self.assertNotEqual(prepared["payload"]["nonce"], self.prepare([self.entry("ask", ask_id, "", "")])["payload"]["nonce"])
|
|
self.assertEqual(self.post_json("/api/sign", {"items": [self.entry("ask", ask_id, "", "")]}, self.client())[0], 403)
|
|
signer = self.pin()
|
|
key(-8, "main").pin(self.approvers, self.origin)
|
|
self.assertEqual(self.prepare([self.entry("ask", ask_id, "", "")])["credentials"], [signer.id, key(-8, "main").id])
|
|
self.assertEqual(self.snapshot()["approvers"], [{"id": signer.id, "alg": "ES256"}, {"id": key(-8, "main").id, "alg": "EdDSA"}])
|
|
self.approvers.chmod(0o666)
|
|
self.assertEqual(self.snapshot()["approvers"], [])
|
|
html = self.index()
|
|
for text in ("Passkey registrieren", "navigator.credentials.get", "navigator.credentials.create", "approval.py pin --port", "~/.config/kvb-hub/approvers.json", "nicht signiert"):
|
|
with self.subTest(text=text):
|
|
self.assertIn(text, html)
|
|
|
|
def test_an_nl_command_records_new_operator_rows_like_the_state_does(self):
|
|
self.write_council({"rasci.json": {"operator/greet": {"title": "echo hi", "workdir": "/repo", "check": "manual", "status": "queued", "roles": {}}}})
|
|
model = mock.Mock(**{"enabled.return_value": True, "complete.return_value": '{"actions": []}'})
|
|
self.httpd.hub = dataclasses.replace(self.httpd.hub, model=model)
|
|
before = time.time()
|
|
self.assertEqual(self.post_json("/api/nl", {"text": "status"}, self.guard(self.host))[0], 200)
|
|
after = time.time()
|
|
row = next(item for item in self.snapshot()["inbox"] if item["id"] == "operator/greet")
|
|
self.assertTrue(before <= row["ts"] <= after, (before, row["ts"], after))
|
|
|
|
def test_the_title_counts_the_items_that_are_not_snoozed(self):
|
|
asks = [self.create_ask(ASK), self.create_ask({**ASK, "command": "make other"})]
|
|
self.assertIn("<title>(2) kvb-hub</title>", self.index())
|
|
for ask_id, title in zip(asks, ("(1) kvb-hub", "kvb-hub"), strict=True):
|
|
snooze = {"kind": "ask", "id": ask_id, "until": time.time() + 3600, "pinned": False}
|
|
self.assertEqual(self.post_json("/api/inbox/mark", snooze, self.guard(self.host))[0], 200)
|
|
with self.subTest(title=title):
|
|
self.assertIn(f"<title>{title}</title>", self.index())
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|