Merge branch 'feature/orchestrator-firewall' into unify/skills-20261112-night

# Conflicts:
#	orchestrator/Dockerfile
#	orchestrator/kvb_orchestrator/view.py
#	orchestrator/templates/index.html.j2
#	orchestrator/templates/page-cleanup.js
#	scripts/orchestrator.sh
This commit is contained in:
Kevin Veen-Birkenbach committed 2026-11-13 18:18:54 +00:00
commit d364cfe55f
48 files changed
+3438 -106

No files matched your search

+275
View File
@@ -0,0 +1,275 @@
from __future__ import annotations
import json
import os
import re
import shutil
import sys
import time
import unittest
from pathlib import Path
HERE = Path(__file__).resolve().parent
sys.path[:0] = [str(HERE.parent), str(HERE)]
import test_orchestrator_e2e as base
from hub_case import HubCase
from hub_support import verifier
from test_settings_writer import ORIGINAL
from test_settings_writer import host as writer_host
OUT = Path(os.environ.get("E2E_OUT", "/tmp/firewall-shots"))
SECRET = ORIGINAL["env"]["EXAMPLE_FLAG"]
SHOW = """(async () => {@HELPERS@
await screenShown(8000);
const ready = await until(() => document.querySelector("#main [data-file] .fw-group"), 10000);
if (!ready) {
return {error: text(document.getElementById("main"))};
}
const owned = (svg) => svg.closest("button, a, [title]");
return {
title: text(document.querySelector("#main h2.title")),
subs: all("#tabs .subtabs button").map(name),
files: all("#main [data-file]").map((node) => node.dataset.file),
groups: all("#main [data-file] details.fw-group[data-tool]").map((node) => [node.dataset.tool, node.dataset.prefix, all("li", node).length]),
lists: all("#main [data-file] li[data-list]").map((node) => [node.dataset.list, node.dataset.entry]),
sandbox: all("#main [data-file] [data-key]").map((node) => node.dataset.key),
patterns: all('#main [aria-label="Never granted"] li').length,
targets: all('#main .rule-form select[aria-label="Applies to"] option').map(text),
unlabelled: all("#main svg.bi").map(owned).filter((owner) => !owner || (!text(owner) && !(owner.getAttribute("title") && owner.getAttribute("aria-label")))).length,
secret: document.documentElement.innerHTML.includes("@SECRET@"),
wide: document.documentElement.scrollWidth > innerWidth + 1,
};
})()"""
SIGN = """(async () => {@HELPERS@
const entryNode = (entry) => all("#main li[data-entry]").find((node) => node.dataset.entry === entry);
if (@REMOVE@) {
entryNode("Bash(git status:*)").querySelector('button[aria-label="Remove"]').click();
await sleep(100);
}
const form = document.querySelector('#main form[aria-label="Stage a settings change"]');
form.querySelector('select[aria-label="Settings file"]').value = "@FILE@";
form.querySelector('select[aria-label="List"]').value = "permissions.allow";
form.querySelector('input[aria-label="Entry"]').value = "@ENTRY@";
form.requestSubmit();
await sleep(100);
const staged = all('#main [aria-label="Staged changes"] li').map((node) => node.dataset.staged);
document.querySelector('#main button[aria-label="Review and sign"]').click();
const diff = await until(() => document.querySelector('.sheet-box [aria-label="Diff"] pre.fw-diff'), 8000);
if (!diff) {
return {error: "no diff", toasts: all("#toasts .toast").map(text)};
}
const lines = (cls) => all(`span.${cls}`, diff).map((node) => node.textContent.trim());
const shown = {added: lines("add"), removed: lines("del"), staged, labelled: all(".sheet-box button").every((button) => text(button) || (button.title && button.getAttribute("aria-label")))};
document.querySelector('.sheet-box button[aria-label="Sign and apply"]').click();
const done = await until(() => document.querySelector(".sheet-box [data-result]"), 30000);
shown.result = done ? done.dataset.result : null;
shown.text = text(done);
shown.toasts = all("#toasts .toast").map(text);
shown.wide = document.documentElement.scrollWidth > innerWidth + 1;
return shown;
})()"""
GROUP_RULE = """(async () => {@HELPERS@
const prompts = [];
new MutationObserver((records) => records.forEach((record) => record.addedNodes.forEach((node) => {
if (node.id === "passkey-prompt") {
prompts.push(text(node));
}
}))).observe(document.body, {childList: true});
const choose = (select, value) => {
select.value = value;
select.dispatchEvent(new Event("change"));
};
const groupValue = (select) => [...select.options].map((option) => option.value).find((value) => value.startsWith("group:"));
const setRow = () => document.querySelector('#main [data-set="ci"]');
const setTarget = () => setRow().querySelector("select");
const setTake = () => setRow().querySelector('button[aria-label="Take over"]');
const setState = () => ({label: text(setTarget().selectedOptions[0]), value: setTarget().value.split(":")[0], blocked: setTake().disabled, valid: setTarget().checkValidity()});
const stage = async (entry) => {
const form = document.querySelector('#main form[aria-label="Stage a settings change"]');
form.querySelector('input[aria-label="Entry"]').value = entry;
form.requestSubmit();
return until(() => all('#main [aria-label="Staged changes"] li').find((node) => node.dataset.staged === `add ${entry}`), 8000);
};
await screenShown(8000);
await until(() => document.querySelector('#main form[aria-label="New agent group"]'), 10000);
const group = document.querySelector('#main form[aria-label="New agent group"]');
group.querySelector('input[aria-label="Group name"]').value = "builders";
for (const option of group.querySelector('select[aria-label="Members"]').options) {
option.selected = true;
}
group.requestSubmit();
const row = await until(() => document.querySelector('#main [data-group="builders"]'), 8000);
const rules = document.querySelector("#main .rule-form");
const target = rules.querySelector('select[aria-label="Applies to"]');
const choice = await until(() => [...target.options].find((option) => option.value.startsWith("group:")), 8000);
if (!row || !choice) {
return {error: "no group", toasts: all("#toasts .toast").map(text)};
}
target.value = choice.value;
rules.querySelector('input[placeholder="make test*"]').value = "make e2e";
rules.requestSubmit();
const pill = await until(() => all("#main .rule-row [data-agents]").find((node) => text(node) === "group builders"), 15000);
const found = {group: text(row.querySelector("strong")), members: text(row.querySelector(".muted")), pills: all("#main .rule-row [data-agents]").map(text), found: Boolean(pill), toasts: all("#toasts .toast").map(text)};
const sets = document.querySelector('#main form[aria-label="New rule set"]');
sets.querySelector('input[aria-label="Set name"]').value = "ci";
for (const option of sets.querySelector('select[aria-label="Rules"]').options) {
option.selected = option.textContent.includes("make e2e");
}
sets.requestSubmit();
if (!await until(setRow, 8000)) {
return {...found, error: "no rule set", toasts: all("#toasts .toast").map(text)};
}
found.fresh = setState();
choose(setTarget(), groupValue(setTarget()));
await stage("Bash(make e2e:*)");
found.kept = setState();
setTake().click();
found.taken = await until(() => all("#toasts .toast").map(text).find((line) => line.startsWith("ci:")), 15000);
found.reloaded = await until(() => setRow() && setTarget().value.startsWith("group:") && document.querySelector("#main .rule-form") && setState(), 8000);
const form = document.querySelector("#main .rule-form");
const picker = form.querySelector('select[aria-label="Applies to"]');
const sign = form.querySelector("[data-sign]");
choose(picker, groupValue(picker));
found.picked = {value: picker.value.split(":")[0], blocked: sign.disabled};
const sent = [];
const fetched = window.fetch;
window.fetch = (url, options) => {
sent.push(String(url));
return fetched(url, options);
};
document.querySelector('#main [data-group="builders"] button[aria-label="Delete group"]').click();
await until(() => picker.value === "gone" || !picker.isConnected, 8000);
found.gone = {connected: picker.isConnected, value: picker.value, label: text(picker.selectedOptions[0]), valid: picker.checkValidity(), blocked: sign.disabled, groups: [...picker.options].filter((option) => option.value.startsWith("group:")).length};
await stage("Bash(make e2e-again:*)");
found.setGone = setState();
setTake().click();
await sleep(500);
found.sent = sent.filter((url) => url.startsWith("/api/rules"));
choose(picker, "all");
found.again = {value: picker.value, valid: picker.checkValidity(), blocked: sign.disabled, options: [...picker.options].map((option) => option.value).includes("gone")};
const ruleRow = () => all("#main .rule-row").find((node) => node.querySelector("[data-agents]") && all("code", node).some((code) => text(code) === "make e2e"));
const toggle = (label) => ruleRow() && [...ruleRow().querySelectorAll("button")].find((button) => text(button) === label);
toggle("Turn off").click();
found.off = Boolean(await until(() => toggle("Turn on"), 8000));
toggle("Turn on").click();
found.on = Boolean(await until(() => toggle("Turn off"), 15000));
found.prompts = prompts;
return found;
})()"""
def signed_lines(rule: dict) -> list[str]:
"""Returns:
The lines the passkey prompt shows for a stored make e2e rule before
its target, its lifetime in days as N.
"""
return ["ask Bash: make e2e", "in *", f"until {time.strftime('%Y-%m-%d %H:%M', time.gmtime(rule['expires']))} UTC, in N days"]
def probe(template: str, values: dict[str, str]) -> str:
text = template.replace("@HELPERS@", base.HELPERS)
for name, value in values.items():
text = text.replace(f"@{name}@", value)
return text
@unittest.skipUnless(shutil.which(os.environ.get("CHROMIUM", "chromium")), "no Chromium")
class TestFirewallE2E(HubCase):
drive = base.TestOrchestratorE2E.drive
beside = base.TestOrchestratorE2E.beside
authenticator = base.TestOrchestratorE2E.authenticator
def setUp(self):
super().setUp()
OUT.mkdir(parents=True, exist_ok=True)
self.claim("s1", "Skills")
self.claim("s2", "Stage")
self.snapshot()
home = self.outside / "home"
self.settings = home / ".claude" / "settings.json"
self.settings.parent.mkdir(parents=True)
self.settings.write_text(json.dumps(ORIGINAL, indent=2) + "\n", encoding="utf-8")
self.settings.chmod(0o640)
tree = self.outside / "writer-tree.json"
tree.write_text(json.dumps({"repos": [{"path": str(self.outside / "demo"), "known": True, "default": "main"}]}), encoding="utf-8")
trust = verifier.Trust(approvers=self.approvers, replay=self.replay / "firewall.json", origin=self.origin)
self.writer = writer_host.Writer(trust, home, tree)
self.spool = self.state / "firewall"
verifier.write_private(self.spool / "view.json", self.writer.view())
self.local = f"http://localhost:{self.port}/"
def host_unit(self) -> None:
if any((self.spool / "jobs").iterdir()):
writer_host.cycle(self.spool / "jobs", self.spool / "results", self.writer)
verifier.write_private(self.spool / "view.json", self.writer.view())
def test_chromium_shows_the_settings_and_signs_a_settings_diff_at_three_widths(self):
authenticator = self.authenticator()
self.beside(self.host_unit)
steps = []
for index, (width, height) in enumerate(base.WIDTHS):
values = {"SECRET": SECRET, "FILE": str(self.settings), "ENTRY": f"Bash(make lint-{width}:*)", "REMOVE": "true" if index == 0 else "false"}
steps.append({"width": width, "height": height, "url": f"{self.local}?{width}#stream/rules", "wait": 1500, "probe": probe(SHOW, values), "shot": str(OUT / f"chromium-{width}-firewall.png")})
steps.append({"width": width, "height": height, "url": None, "wait": 0, "probe": probe(SIGN, values), "shot": str(OUT / f"chromium-{width}-firewall-signed.png")})
data = self.drive(steps, authenticator)
(OUT / "chromium-firewall.json").write_text(json.dumps(data, indent=1), encoding="utf-8")
self.assertEqual(data["errors"], [])
for index, (width, _) in enumerate(base.WIDTHS):
shown, signed = data["results"][2 * index : 2 * index + 2]
with self.subTest(width=width):
self.assertNotIn("error", shown, shown)
self.assertEqual((shown["title"], shown["subs"]), ("Firewall", base.SUBS))
self.assertEqual(shown["files"], [str(self.settings), str(self.outside / "demo" / ".claude" / "settings.json")])
self.assertIn(["Bash", "make", 1 + index], shown["groups"])
self.assertIn(["Read", "~/.ssh/**", 1], shown["groups"])
self.assertIn(["sandbox.filesystem.allowWrite", "/tmp"], shown["lists"])
self.assertIn("sandbox.enabled", shown["sandbox"])
self.assertGreater(shown["patterns"], 5)
self.assertEqual(shown["targets"], ["All agents", "Agent Skills", "Agent Stage"])
self.assertEqual((shown["unlabelled"], shown["secret"], shown["wide"]), (0, False, False))
self.assertNotIn("error", signed, signed)
self.assertTrue(any(line.startswith("+") and f'"Bash(make lint-{width}:*)"' in line for line in signed["added"]), signed["added"])
self.assertEqual(any("git status" in line for line in signed["removed"]), index == 0)
self.assertEqual((signed["result"], signed["labelled"], signed["wide"]), ("done", True, False), signed)
self.assertIn("Settings: written", " ".join(signed["toasts"]))
written = json.loads(self.settings.read_text(encoding="utf-8"))
self.assertEqual(written["permissions"]["allow"], ["Bash(make test:*)", *(f"Bash(make lint-{width}:*)" for width, _ in base.WIDTHS)])
self.assertEqual({key: written[key] for key in ("model", "env", "hooks", "sandbox")}, {key: ORIGINAL[key] for key in ("model", "env", "hooks", "sandbox")})
backups = sorted(self.settings.parent.glob("settings.json.before-firewall-*"))
self.assertEqual((len(backups), self.settings.stat().st_mode & 0o777), (3, 0o640))
def test_chromium_names_a_group_and_signs_a_rule_for_it(self):
authenticator = self.authenticator()
steps = [{"width": 1366, "height": 768, "url": f"{self.local}#stream/rules", "wait": 1500, "probe": probe(GROUP_RULE, {}), "shot": str(OUT / "chromium-1366-firewall-group-rule.png")}]
data = self.drive(steps, authenticator)
(OUT / "chromium-firewall-group.json").write_text(json.dumps(data, indent=1), encoding="utf-8")
self.assertEqual(data["errors"], [])
found = data["results"][0]
self.assertNotIn("error", found, found)
self.assertEqual((found["group"], found["members"], found["found"]), ("builders", "Skills, Stage", True), found)
stored = [rule for rule in self.httpd.hub.rules.listed() if rule["pattern"] == "make e2e"]
self.assertEqual([(rule["agents"], rule["proof"]["payload"]["agents"]) for rule in stored], [(["s1", "s2"], ["s1", "s2"])] * 2)
for rule in stored:
self.assertLess(abs(rule["expires"] - (time.time() + 7 * 86400)), 2 * 86400)
self.assertEqual(found["fresh"], {"label": "Pick a target", "value": "", "blocked": True, "valid": False}, found)
self.assertEqual(found["kept"], {"label": "Group builders", "value": "group", "blocked": False, "valid": True}, found)
self.assertEqual(found["taken"], "ci: 1 of 1 rules signed for group builders")
self.assertEqual(found["reloaded"], found["kept"])
self.assertEqual(found["setGone"], {"label": "Target gone: pick again", "value": "gone", "blocked": True, "valid": False}, found)
self.assertEqual(found["sent"], [])
members = "Skills (s1), Stage (s2)"
shown = [re.sub(r"in \d+\.\d days$", "in N days", prompt.removeprefix("Passkey signs"), flags=re.MULTILINE).split("\n") for prompt in found["prompts"]]
made = sorted(stored, key=lambda rule: rule["created_ts"])
self.assertEqual(shown[:2], [["Rule", *signed_lines(made[0]), f"for group builders: {members}"], ["Rule set ci", *signed_lines(made[1]), f"for group builders: {members}"]], found)
self.assertIn(shown[2:], [[["Turn on rule", *signed_lines(rule), f"for agents {members}"]] for rule in made], found)
self.assertTrue(found["prompts"][1].split("\n")[3].endswith("in 7.0 days"), found["prompts"])
self.assertEqual((found["off"], found["on"], [rule["enabled"] for rule in self.httpd.hub.rules.listed() if rule["pattern"] == "make e2e"]), (True, True, [True, True]))
self.assertEqual(found["picked"], {"value": "group", "blocked": False})
self.assertEqual(found["gone"], {"connected": True, "value": "gone", "label": "Target gone: pick again", "valid": False, "blocked": True, "groups": 0}, found)
self.assertEqual(found["again"], {"value": "all", "valid": True, "blocked": False, "options": False}, found)
self.assertEqual(self.httpd.hub.groups.listed(), [])
if __name__ == "__main__":
unittest.main()
+60 -1
View File
@@ -1,5 +1,6 @@
from __future__ import annotations
import importlib
import json
import socket
import subprocess
@@ -10,7 +11,7 @@ import unittest
from collections.abc import Callable
from hub_case import HubCase
from hub_support import ASK, CLIENT, HOOK, OPTIONS, Key, key
from hub_support import ASK, CLIENT, HOOK, OPTIONS, Key, key, signing
class TestHubAsks(HubCase):
@@ -155,6 +156,64 @@ class TestHubAsks(HubCase):
result = self.tool(tool, {"id": "0123456789abcdef", "timeout_seconds": -1})
self.assertEqual(result["content"][0]["text"], "timeout_seconds must be a finite number of seconds, 0 or more")
def test_an_ask_with_an_invisible_format_character_is_refused_before_it_reaches_a_prompt(self):
for name, value, code in (
("command", f"git status{chr(0x202E)} && rm -rf ~", "U+202E"),
("command", f"make{chr(0x200B)} test", "U+200B"),
("command", f"rm{chr(0xA0)}-rf ~", "U+00A0"),
("command", f"make{chr(0x3164)} test", "U+3164"),
("command", f"make test{chr(0xFE0F)}", "U+FE0F"),
("cwd", f"/repo{chr(0x2066)}", "U+2066"),
("session", f"s1{chr(0x200D)}", "U+200D"),
("tool", f"{chr(0xFEFF)}Bash", "U+FEFF"),
):
with self.subTest(code=code):
status, _, body = self.post_json("/api/asks", {**ASK, name: value}, self.local())
self.assertEqual(status, 400)
self.assertIn(code, body.decode("utf-8"))
self.assertEqual(self.httpd.hub.asks.listed(), [])
self.assertEqual([item for item in self.snapshot()["inbox"] if item["kind"] == "ask"], [])
self.create_ask(ASK)
def test_a_score_block_with_emoji_presentation_reaches_the_prompt_and_a_stray_selector_does_not(self):
vs16 = chr(0xFE0F)
score = f"🎯 Fix: 93\n💥 Break: 4\n{chr(0x23F1)}{vs16} Time: 20\n{chr(0x1F6E1)}{vs16} Security: 100\n🏆 Score: 90"
ask_id = self.create_ask({**ASK, "command": f'git commit -m "fix: x" -m "{score}"'})
self.assertEqual(self.post_json("/api/sign", {"items": [self.entry("ask", ask_id, "", "")]}, self.guard(self.host))[0], 200)
result = self.tool("decision_request", {"question": f"Commit?\n{score}", "options": [{**OPTIONS[0], "description": score}, OPTIONS[1]], "agent": "Skills", "recommended": ""})
self.assertFalse(result["isError"], result)
for command in (f"make {chr(0x23F1)}{vs16}{vs16}", f"make{vs16}", f"{vs16}{chr(0x23F1)}"):
with self.subTest(command=command):
status, _, body = self.post_json("/api/asks", {**ASK, "command": command}, self.local())
self.assertEqual(status, 400)
self.assertIn("U+FE0F", body.decode("utf-8"))
self.assertIn(f'id="emoji-bases" type="application/json">{json.dumps(sorted(signing.EMOJI_BASES))}</script>', self.index())
def test_the_hook_names_the_reason_the_hub_refused_an_ask_on_one_line(self):
process = self.hook(self.port, "3", {**HOOK, "tool_input": {"command": f"rm{chr(0xA0)}-rf node_modules"}})
self.assertEqual(self.finish(process), (0, ""))
self.assertRegex(process.stderr.read(), r"\Akvb-orchestrator: the hub answered 400, Claude Code asks instead: command must hold no [^\n]*U\+00A0[^\n]*\n\Z")
self.assertEqual(self.httpd.hub.asks.listed(), [])
def test_the_hook_prints_no_control_or_bidi_character_of_a_reason(self):
hook = importlib.import_module("permission_hook")
reason = f" stop{chr(0x9B)}31m{chr(0x202E)}txt\nnext{chr(0x7F)}{chr(0x2066)} {chr(0x23F1)}{chr(0xFE0F)} 20 "
self.assertEqual(hook.clean(reason), f"stop?31m?txt?next?? {chr(0x23F1)}{chr(0xFE0F)} 20")
def test_a_decision_with_an_invisible_format_character_is_refused_before_it_reaches_a_prompt(self):
plain = {"question": "Merge the hub?", "options": OPTIONS, "agent": "Skills", "recommended": ""}
for change, code in (
({"question": f"Merge{chr(0x202E)} the hub?"}, "U+202E"),
({"options": [{**OPTIONS[0], "description": f"Gate{chr(0x200B)} is green"}, OPTIONS[1]]}, "U+200B"),
({"options": [{**OPTIONS[0], "label": f"Merge now{chr(0x2067)}"}, OPTIONS[1]]}, "U+2067"),
):
with self.subTest(code=code):
result = self.tool("decision_request", {**plain, **change})
self.assertTrue(result["isError"])
self.assertIn(code, json.dumps(result, ensure_ascii=True))
self.assertEqual(self.httpd.hub.decisions.listed(), [])
self.assertFalse(self.tool("decision_request", plain)["isError"])
def test_decisions_are_requested_chosen_and_waited_for(self):
for arguments in (
{"question": "Merge?", "options": [], "agent": "Skills"},
+18
View File
@@ -32,6 +32,24 @@ class TestHubExecutors(HubCase):
def trust(self, name: str) -> verifier.Trust:
return verifier.Trust(approvers=self.approvers, replay=self.replay / f"{name}.json", origin=self.origin)
def test_an_operator_row_with_an_invisible_format_character_is_never_offered_for_a_signature(self):
rows = {
"operator/bidi": (f"echo safe{chr(0x202E)} && rm -rf ~", str(self.outside)),
"operator/zero": (f"make{chr(0x200B)} test", str(self.outside)),
"operator/dir": ("make test", f"{self.outside}{chr(0x2066)}"),
"operator/plain": ("make test", str(self.outside)),
}
self.write_council({"rasci.json": {task: {"title": command, "workdir": workdir, "description": "run it", "check": "manual", "status": "queued", "roles": {}} for task, (command, workdir) in rows.items()}})
self.pin()
for task, code in (("operator/bidi", "U+202E"), ("operator/zero", "U+200B"), ("operator/dir", "U+2066")):
with self.subTest(task=task):
entry = self.entry("operator", task, "", hashlib.sha256(rows[task][0].encode()).hexdigest())
status, _, body = self.post_json("/api/sign", {"items": [entry]}, self.guard(self.host))
self.assertEqual(status, 400)
self.assertIn(code, body.decode("utf-8"))
plain = self.entry("operator", "operator/plain", "", hashlib.sha256(b"make test").hexdigest())
self.assertEqual(len(self.prepare([plain])["payload"]["items"]), 1)
def test_the_runner_runs_only_signed_commands_once(self):
command = "echo hello && echo world >&2"
register = {
+366
View File
@@ -0,0 +1,366 @@
from __future__ import annotations
import functools
import json
import time
from unittest import mock
from hub_case import HubCase
from hub_support import ASK, PRESENT, key, signing, verifier
from kvb_orchestrator import batches, rules
HOME_FILE = "/home/op/.claude/settings.json"
PROJECT_FILE = "/home/op/Repositories/demo/.claude/settings.json"
SHA = "ab" * 32
PERMISSIONS = {
"allow": ["Bash(make test:*)", "Bash(make lint:*)", "Bash(git status:*)", "WebFetch(domain:example.org)", "mcp__memory__search"],
"ask": ["Bash(git push:*)"],
"deny": ["Read(~/.ssh/**)", 7],
}
SANDBOX = {"enabled": True, "filesystem": {"allowWrite": ["/tmp", "~/Repositories"]}, "network": {"allowLocalBinding": False}}
ADD = {"list": "permissions.allow", "op": "add", "entry": "Bash(make build:*)"}
class TestHubFirewall(HubCase):
def setUp(self):
super().setUp()
self.claim("s1", "Skills")
self.claim("s2", "Stage")
self.snapshot()
def view(self, files: list[dict]) -> None:
(self.state / "firewall" / "view.json").write_text(json.dumps({"written": time.time(), "files": files}), encoding="utf-8")
def home_view(self) -> dict:
return {"path": HOME_FILE, "exists": True, "sha256": SHA, "error": "", "settings": {"permissions": PERMISSIONS, "sandbox": SANDBOX, "env": {"EXAMPLE_FLAG": "fixture-value-not-a-secret"}}}
def firewall(self) -> dict:
status, _, body = self.get("/api/firewall")
self.assertEqual(status, 200, body)
return json.loads(body)
def post(self, path: str, payload: object) -> tuple[int, bytes]:
status, _, body = self.post_json(path, payload, self.guard(self.host))
return status, body
def test_the_firewall_groups_the_settings_by_tool_and_prefix_and_lists_the_deny_patterns(self):
self.assertEqual(self.firewall()["files"], [])
self.assertIn("kvb-orchestrator-firewall", self.firewall()["error"])
self.view([self.home_view(), {"path": PROJECT_FILE, "exists": False, "sha256": "", "error": "", "settings": {}}, {"path": "/x", "exists": "yes", "sha256": "", "settings": {}}])
found = self.firewall()
self.assertEqual([entry["path"] for entry in found["files"]], [HOME_FILE, PROJECT_FILE])
groups = [(group["tool"], group["prefix"], [(entry["list"], entry["entry"]) for entry in group["entries"]]) for group in found["files"][0]["groups"]]
self.assertEqual(groups, [
("Bash", "git", [("allow", "Bash(git status:*)"), ("ask", "Bash(git push:*)")]),
("Bash", "make", [("allow", "Bash(make test:*)"), ("allow", "Bash(make lint:*)")]),
("Read", "~/.ssh/**", [("deny", "Read(~/.ssh/**)")]),
("WebFetch", "domain", [("allow", "WebFetch(domain:example.org)")]),
("mcp__memory__search", "", [("allow", "mcp__memory__search")]),
])
self.assertEqual(found["files"][0]["sandbox"], [{"key": "sandbox.enabled", "value": True}, {"key": "sandbox.filesystem.allowWrite", "values": ["/tmp", "~/Repositories"]}, {"key": "sandbox.network.allowLocalBinding", "value": False}])
self.assertEqual(found["lists"], list(signing.SETTINGS_LISTS))
self.assertEqual([pattern["label"] for pattern in found["patterns"]][:len(signing.WARNINGS)], [label for label, _ in signing.WARNINGS])
self.assertNotIn("fixture-value-not-a-secret", json.dumps(found))
for path in ("/api/firewall/preview", "/api/firewall/settings", "/api/firewall/groups", "/api/firewall/sets", "/api/firewall/groups/0123456789abcdef/delete"):
with self.subTest(path=path):
self.assertEqual(self.get(path)[0], 405)
self.assertEqual(self.get("/api/firewall/settings/0123456789abcdef")[0], 404)
def test_a_settings_change_is_previewed_signed_and_queued_for_the_host(self):
self.view([self.home_view()])
item = {"kind": "settings", "file": HOME_FILE, "base": SHA, "changes": [ADD, {"list": "permissions.ask", "op": "remove", "entry": "Bash(git push:*)"}]}
status, body = self.post("/api/firewall/preview", {"items": [item]})
self.assertEqual(status, 200, body)
diff = json.loads(body)["diffs"][0]["diff"]
changed = [line for line in diff.splitlines() if line[:1] in "+-" and line[:3] not in ("+++", "---")]
self.assertEqual([line[0] + line[1:].strip() for line in changed], ['-"mcp__memory__search"', '+"mcp__memory__search",', '+"Bash(make build:*)"', '-"ask": [', '-"Bash(git push:*)"', '-],', '+"ask": [],'])
self.assertNotIn("EXAMPLE_FLAG", diff)
signed = signing.settings_item(HOME_FILE, SHA, item["changes"])
self.assertEqual(self.prepare([item])["payload"]["items"], [signing.item_hash(signed)])
signer = self.pin()
proof = signer.proof(self.prepare([item])["payload"], self.origin)
for name, items, proven, expected in (
("no proof", [item], None, 400),
("forged", [item], key(-7, "intruder").proof(self.prepare([item])["payload"], self.origin), 400),
("stale base", [{**item, "base": "cd" * 32}], proof, 409),
("unlisted file", [{**item, "file": PROJECT_FILE}], proof, 400),
("hooks list", [{**item, "changes": [{**ADD, "list": "hooks.Stop"}]}], proof, 400),
("added twice", [{**item, "changes": [{**ADD, "entry": "Bash(make test:*)"}]}], proof, 400),
("two items for one file", [item, item], proof, 400),
("other item signed", [{**item, "changes": [ADD]}], proof, 400),
):
with self.subTest(name=name):
self.assertEqual(self.post("/api/firewall/settings", {"items": items, "proof": proven})[0], expected)
self.assertEqual(self.post_json("/api/firewall/settings", {"items": [item], "proof": proof}, {"Host": self.host})[0], 403)
self.assertEqual(list((self.state / "firewall" / "jobs").iterdir()), [])
status, body = self.post("/api/firewall/settings", {"items": [item], "proof": proof})
self.assertEqual(status, 202, body)
job_id = json.loads(body)["id"]
written = self.state / "firewall" / "jobs" / f"{job_id}.json"
job = json.loads(written.read_text(encoding="utf-8"))
self.assertEqual((sorted(job), job["items"], job["proof"]), (["created", "id", "items", "proof", "v"], [{name: signed[name] for name in signing.SETTINGS_KEYS}], proof))
self.assertEqual(written.stat().st_mode & 0o777, 0o600)
self.assertEqual(self.post("/api/firewall/settings", {"items": [item], "proof": proof})[0], 400)
self.assertEqual(json.loads(self.get(f"/api/firewall/settings/{job_id}")[2])["status"], "queued")
result = {"id": job_id, "finished": time.time(), "items": [{**job["items"][0], "status": "done", "reason": ""}]}
(self.state / "firewall" / "results" / f"{job_id}.json").write_text(json.dumps(result), encoding="utf-8")
self.assertEqual(json.loads(self.get(f"/api/firewall/settings/{job_id}")[2])["status"], "done")
def test_a_settings_entry_or_path_with_an_invisible_format_character_is_refused_before_it_reaches_a_prompt(self):
self.view([self.home_view()])
for name, item, code in (
("bidi override in an entry", {"kind": "settings", "file": HOME_FILE, "base": SHA, "changes": [{**ADD, "entry": f"Bash(make build{chr(0x202E)}:*)"}]}, "U+202E"),
("zero-width space in an entry", {"kind": "settings", "file": HOME_FILE, "base": SHA, "changes": [{**ADD, "entry": f"Bash(make{chr(0x200B)} build:*)"}]}, "U+200B"),
("no-break space in a deny entry", {"kind": "settings", "file": HOME_FILE, "base": SHA, "changes": [{"list": "permissions.deny", "op": "add", "entry": f"Bash(rm{chr(0xA0)}-r:*)"}]}, "U+00A0"),
("ideographic space in a deny entry", {"kind": "settings", "file": HOME_FILE, "base": SHA, "changes": [{"list": "permissions.deny", "op": "add", "entry": f"Bash(rm{chr(0x3000)}-r:*)"}]}, "U+3000"),
("Hangul filler in an entry", {"kind": "settings", "file": HOME_FILE, "base": SHA, "changes": [{**ADD, "entry": f"Bash(make{chr(0x3164)} build:*)"}]}, "U+3164"),
("grapheme joiner in an entry", {"kind": "settings", "file": HOME_FILE, "base": SHA, "changes": [{**ADD, "entry": f"Bash(make{chr(0x34F)} build:*)"}]}, "U+034F"),
("variation selector in an entry", {"kind": "settings", "file": HOME_FILE, "base": SHA, "changes": [{**ADD, "entry": f"Bash(make build{chr(0xE0100)}:*)"}]}, "U+E0100"),
("Hangul filler in a path", {"kind": "settings", "file": f"/home/op{chr(0xFFA0)}/.claude/settings.json", "base": SHA, "changes": [ADD]}, "U+FFA0"),
):
with self.subTest(name=name):
for path in ("/api/firewall/preview", "/api/sign"):
status, body = self.post(path, {"items": [item]})
self.assertEqual(status, 400)
self.assertIn(code, body.decode("utf-8"))
self.assertIn("U+2067", signing.settings_problem({"file": f"/home/op{chr(0x2067)}/.claude/settings.json", "base": SHA, "changes": [ADD]}))
self.assertIn("U+FEFF", signing.settings_problem({"file": HOME_FILE, "base": SHA, "changes": [{**ADD, "entry": f"{chr(0xFEFF)}Bash(make build:*)"}]}))
self.assertIsNone(signing.settings_problem({"file": HOME_FILE, "base": SHA, "changes": [ADD]}))
self.assertEqual(self.post("/api/firewall/preview", {"items": [{"kind": "settings", "file": HOME_FILE, "base": SHA, "changes": [ADD]}]})[0], 200)
def test_removing_a_settings_entry_with_a_hidden_character_is_offered_and_adding_one_is_not(self):
hidden = f"Bash(make{chr(0x202E)} build:*)"
self.view([{**self.home_view(), "settings": {"permissions": {**PERMISSIONS, "allow": [*PERMISSIONS["allow"], hidden]}, "sandbox": SANDBOX}}])
removal = {"kind": "settings", "file": HOME_FILE, "base": SHA, "changes": [{"list": "permissions.allow", "op": "remove", "entry": hidden}]}
addition = {**removal, "changes": [{"list": "permissions.ask", "op": "add", "entry": hidden}]}
for path in ("/api/firewall/preview", "/api/sign"):
with self.subTest(path=path):
self.assertEqual(self.post(path, {"items": [removal]})[0], 200)
status, body = self.post(path, {"items": [addition]})
self.assertEqual(status, 400)
self.assertIn("U+202E", body.decode("utf-8"))
self.assertIsNone(signing.hidden_problem(removal["changes"][0], "change"))
for name, value in (
("no list", {"op": "remove", "entry": hidden}),
("extra key", {**removal["changes"][0], "note": "x"}),
("unknown list", {**removal["changes"][0], "list": "permissions.other"}),
("an ask with op remove", {"kind": "ask", "op": "remove", "entry": hidden}),
("nested in an item", {"kind": "review", "branch": {"op": "remove", "entry": hidden}}),
):
with self.subTest(name=name):
self.assertIn("U+202E", signing.hidden_problem(value, "item"))
def test_a_group_set_addressee_legacy_rule_or_pattern_with_a_hidden_character_is_never_offered_for_a_signature(self):
rlo = chr(0x202E)
signer = self.pin()
rule = self.signed_rule(signer, {"kind": "ask", "tool": "Bash", "pattern": "make *", "scope": "/repo*", "expires": time.time() + 3600, "agents": ["s1"]})
for path, payload in (("/api/firewall/groups", {"name": f"ci{rlo}", "members": ["s1"]}), ("/api/firewall/sets", {"name": f"ci{rlo}", "days": 7, "rules": [rule["id"]]})):
with self.subTest(path=path):
status, body = self.post(path, payload)
self.assertEqual(status, 400)
self.assertIn("U+202E", body.decode("utf-8"))
for code in (0x2028, 0x2029, 0x85, 0x0B, 0x0D, 0x34F, 0xFE0F, 0xE0100, 0x3164, 0x1160, 0xA0, 0x3000):
with self.subTest(code=code):
status, body = self.post("/api/rules/sign", {"kind": "ask", "tool": "Bash", "pattern": f"make test{chr(code)}in /safe", "scope": "/repo*", "expires": time.time() + 3600})
self.assertEqual(status, 400)
self.assertIn(f"U+{code:04X}", body.decode("utf-8"))
stored = self.httpd.hub.rules.get(rule["id"])
legacy = {key: value for key, value in stored["proof"]["payload"].items() if key != signing.TARGET}
self.httpd.hub.rules.change(rule["id"], {"enabled": False, "proof": {**stored["proof"], "payload": {**legacy, "pattern": f"make test{rlo}*"}}})
status, body = self.post("/api/sign", {"items": [{"kind": "enable", "rule": rule["id"]}]})
self.assertEqual(status, 400)
self.assertIn("U+202E", body.decode("utf-8"))
self.claim("s1", f"Skills{rlo}")
ask_id = self.create_ask(ASK)
shown = next(item for item in self.snapshot()["inbox"] if item["id"] == ask_id)
self.assertIn(rlo, shown["to"])
status, body = self.post("/api/sign", {"items": [{**self.entry("ask", ask_id, "", ""), "verb": "reject", "channel": "post", "reason": "no", "to": shown["to"]}]})
self.assertEqual(status, 400)
self.assertIn("U+202E", body.decode("utf-8"))
self.assertEqual(self.post("/api/sign", {"items": [self.entry("ask", ask_id, "", "")]})[0], 200)
def test_the_hub_keeps_only_permissions_and_sandbox_and_refuses_a_view_unsafe_to_copy(self):
self.view([self.home_view()])
files, _ = self.httpd.hub.settings_files()
self.assertEqual(sorted(files[0]["settings"]), ["permissions", "sandbox"])
domain = {"kind": "settings", "file": HOME_FILE, "base": SHA, "changes": [{"list": "sandbox.network.allowedDomains", "op": "add", "entry": "example.org"}]}
status, body = self.post("/api/firewall/preview", {"items": [domain]})
self.assertEqual(status, 200, body)
self.assertNotIn('"env"', json.loads(body)["diffs"][0]["diff"])
deep = functools.reduce(lambda inner, _: {"x": inner}, range(600), {})
for name, extra, reason in (("600 levels", deep, "nests deeper than 64"), ("lone surrogate", "\ud800", "lone surrogate")):
with self.subTest(name=name):
self.view([{**self.home_view(), "settings": {"permissions": {**PERMISSIONS, "extra": extra}, "sandbox": SANDBOX}}])
status, body = self.post("/api/firewall/preview", {"items": [{**domain, "changes": [ADD]}]})
self.assertEqual(status, 400, body)
self.assertIn(reason, body.decode("utf-8"))
def test_groups_and_rule_sets_hold_known_agents_and_stored_rules(self):
for name, payload, expected in (
("unknown session", {"name": "builders", "members": ["s1", "s9"]}, 400),
("every agent", {"name": "builders", "members": ["*"]}, 400),
("unsorted", {"name": "builders", "members": ["s2", "s1"]}, 400),
("empty name", {"name": " ", "members": ["s1"]}, 400),
("extra key", {"name": "builders", "members": ["s1"], "rule": "x"}, 400),
):
with self.subTest(name=name):
self.assertEqual(self.post("/api/firewall/groups", payload)[0], expected)
status, body = self.post("/api/firewall/groups", {"name": "builders", "members": ["s1", "s2"]})
self.assertEqual(status, 201, body)
group = json.loads(body)
self.assertEqual(self.post("/api/firewall/groups", {"name": "builders", "members": ["s1"]})[0], 409)
self.assertEqual([(entry["name"], entry["members"]) for entry in self.firewall()["groups"]], [("builders", ["s1", "s2"])])
signer = self.pin()
rule = self.signed_rule(signer, {"kind": "ask", "tool": "Bash", "pattern": "make *", "scope": "/repo*", "expires": time.time() + 3600, "agents": ["s1"]})
for name, payload in (("no days", {"name": "ci", "days": 0, "rules": [rule["id"]]}), ("unknown rule", {"name": "ci", "days": 7, "rules": ["0123456789abcdef"]}), ("no rules", {"name": "ci", "days": 7, "rules": []})):
with self.subTest(name=name):
self.assertEqual(self.post("/api/firewall/sets", payload)[0], 400)
status, body = self.post("/api/firewall/sets", {"name": "ci", "days": 7, "rules": [rule["id"]]})
self.assertEqual(status, 201, body)
stored = json.loads(body)
self.assertEqual((stored["days"], stored["rules"]), (7, [{"kind": "ask", "tool": "Bash", "pattern": "make *", "scope": "/repo*"}]))
for path, ident in (("groups", group["id"]), ("sets", stored["id"])):
with self.subTest(path=path):
self.assertEqual(self.call("POST", f"/api/firewall/{path}/{ident}/delete", b"", self.guard(self.host))[0], 200)
self.assertEqual(self.call("POST", f"/api/firewall/{path}/{ident}/delete", b"", self.guard(self.host))[0], 404)
def signed_rule(self, signer, fields: dict) -> dict:
status, _, body = self.post_json("/api/rules/sign", fields, self.guard(self.host))
self.assertEqual(status, 200, body)
payload = json.loads(body)["payload"]
status, _, body = self.post_json("/api/rules", {"rule": payload, "assertion": signer.assertion(payload, self.origin, "localhost", PRESENT, 0), "enabled": True}, self.guard(self.host))
self.assertEqual(status, 201, body)
return json.loads(body)
def test_a_rule_applies_to_one_agent_a_group_or_every_agent(self):
signer = self.pin()
now = time.time()
base = {"kind": "ask", "tool": "Bash", "scope": "/repo*", "expires": now + 3600}
for name, agents in (("unknown agent", ["s9"]), ("unsorted group", ["s2", "s1"]), ("pseudo agent", ["name:Docs"]), ("empty", [])):
with self.subTest(name=name):
self.assertEqual(self.post_json("/api/rules/sign", {**base, "pattern": "make *", "agents": agents}, self.guard(self.host))[0], 400)
self.assertEqual(self.post_json("/api/rules/sign", {"kind": "review", "tool": "", "pattern": "feature/*", "scope": "/repo/*", "expires": now + 3600, "agents": ["s1"]}, self.guard(self.host))[0], 400)
one = self.signed_rule(signer, {**base, "pattern": "make one", "agents": ["s1"]})
group = self.signed_rule(signer, {**base, "pattern": "make group", "agents": ["s1", "s2"]})
every = self.signed_rule(signer, {**base, "pattern": "make every"})
self.assertEqual((one["agents"], group["agents"], every["agents"]), (["s1"], ["s1", "s2"], ["*"]))
self.assertEqual(one["proof"]["payload"]["agents"], ["s1"])
with mock.patch.object(batches, "UNDO", 0.05):
asks = {(command, session): self.create_ask({**ASK, "command": command, "session": session}) for command in ("make one", "make group", "make every") for session in ("s1", "s2", "s3")}
time.sleep(0.6)
statuses = {pair: self.ask_status(ask_id, "0") for pair, ask_id in asks.items()}
self.assertEqual(statuses, {
("make one", "s1"): "allowed", ("make one", "s2"): "pending", ("make one", "s3"): "pending",
("make group", "s1"): "allowed", ("make group", "s2"): "allowed", ("make group", "s3"): "pending",
("make every", "s1"): "allowed", ("make every", "s2"): "allowed", ("make every", "s3"): "allowed",
})
hook = verifier.Trust(approvers=self.approvers, replay=self.replay / "hook.json", origin=self.origin)
relayed = json.loads(self.get(f"/api/asks/{asks[('make one', 's1')]}?wait=0")[2])["proof"]
verifier.check(relayed, signing.ask_item(asks[("make one", "s1")], "Bash", "make one", "/repo", "s1"), "", hook, time.time())
with self.assertRaisesRegex(signing.Refused, "does not match"):
verifier.check(relayed, signing.ask_item(asks[("make one", "s2")], "Bash", "make one", "/repo", "s2"), "", hook, time.time())
def test_a_decision_rule_scoped_to_an_agent_decides_only_decisions_under_the_name_it_holds_now(self):
for session, name in (("s1", "Docs"), ("s1", "Main"), ("s1", "Skills"), ("s2", "Main")):
time.sleep(1.1)
self.claim(session, name)
self.snapshot()
held = {(entry["session"], entry["name"]) for entry in self.httpd.hub.names.listed()}
self.assertLessEqual({("s1", "Docs"), ("s1", "Main"), ("s1", "Skills"), ("s2", "Main")}, held)
signer = self.pin()
self.signed_rule(signer, {"kind": "decision", "tool": "", "pattern": "*", "scope": "*", "expires": time.time() + 3600, "agents": ["s1"]})
options = [{"label": "Yes", "description": ""}, {"label": "No", "description": ""}]
with mock.patch.object(batches, "UNDO", 0.05):
asked = {name: self.tool("decision_request", {"question": "Merge?", "options": options, "agent": name, "recommended": "Yes"})["structuredContent"]["id"] for name in ("Skills", "Main", "Docs", "Stage")}
self.settle(lambda: self.choice(asked["Skills"]) == "Yes")
time.sleep(0.3)
self.assertEqual({name: self.choice(decision) for name, decision in asked.items()}, {"Skills": "Yes", "Main": None, "Docs": None, "Stage": None})
self.claim("s3", "Skills")
self.snapshot()
with mock.patch.object(batches, "UNDO", 0.05):
shared = self.tool("decision_request", {"question": "Merge?", "options": options, "agent": "Skills", "recommended": "Yes"})["structuredContent"]["id"]
time.sleep(0.6)
self.assertIsNone(self.choice(shared))
def test_turning_a_rule_on_needs_a_fresh_passkey_signature_and_turning_it_off_none(self):
signer = self.pin()
rule = self.signed_rule(signer, {"kind": "ask", "tool": "Bash", "pattern": "make *", "scope": "/repo*", "expires": time.time() + 3600})
other = self.signed_rule(signer, {"kind": "ask", "tool": "Bash", "pattern": "make other", "scope": "/repo*", "expires": time.time() + 3600})
enable = f"/api/rules/{rule['id']}/enable"
self.assertEqual(self.call("POST", f"/api/rules/{rule['id']}/disable", b"", self.guard(self.host))[0], 200)
unsigned = (("no body", b""), ("no proof", b'{"proof": null}'), ("the rule's own signature", json.dumps({"proof": rule["proof"]}).encode()))
for name, body in unsigned:
with self.subTest(name=name):
self.assertEqual(self.call("POST", enable, body, self.guard(self.host))[0], 400)
self.assertFalse(self.httpd.hub.rules.get(rule["id"])["enabled"])
offer = self.prepare([{"kind": "enable", "rule": rule["id"]}])
self.assertEqual((offer["enables"], offer["payload"]["items"]), (rule["proof"]["payload"], [signing.item_hash(signing.enable_item(rule["proof"]["payload"]))]))
self.assertEqual(self.post("/api/sign", {"items": [{"kind": "enable", "rule": "0123456789abcdef"}]})[0], 404)
proof = signer.proof(offer["payload"], self.origin)
foreign = signer.proof(self.prepare([{"kind": "enable", "rule": other["id"]}])["payload"], self.origin)
for name, body in (("forged", {"proof": key(-7, "intruder").proof(offer["payload"], self.origin)}), ("another rule's approval", {"proof": foreign})):
with self.subTest(name=name):
self.assertEqual(self.post(enable, body)[0], 400)
self.assertFalse(self.httpd.hub.rules.get(rule["id"])["enabled"])
with mock.patch.object(batches, "UNDO", 0.05):
waiting = self.create_ask({**ASK, "command": "make x", "session": "s1"})
time.sleep(0.6)
self.assertEqual(self.ask_status(waiting, "0"), "pending")
status, body = self.post(enable, {"proof": proof})
self.assertEqual((status, json.loads(body)["enabled"]), (200, True), body)
self.assertEqual(self.call("POST", f"/api/rules/{rule['id']}/disable", b"", self.guard(self.host))[0], 200)
self.assertEqual(self.post(enable, {"proof": proof})[0], 400)
self.assertFalse(self.httpd.hub.rules.get(rule["id"])["enabled"])
def test_a_deleted_rule_never_comes_back_with_its_old_proof_and_a_fresh_signature_does(self):
signer = self.pin()
fields = {"kind": "ask", "tool": "Bash", "pattern": "make *", "scope": "/repo*", "expires": time.time() + 3600}
rule = self.signed_rule(signer, fields)
old = {"rule": rule["proof"]["payload"], "assertion": rule["proof"]["assertion"], "enabled": True}
self.assertEqual(self.post("/api/rules", old)[0], 409)
self.assertEqual(self.call("POST", f"/api/rules/{rule['id']}/delete", b"", self.guard(self.host))[0], 200)
self.assertEqual(self.post("/api/rules", old)[0], 409)
self.assertIsNone(self.httpd.hub.rules.get(rule["id"]))
unsigned = json.loads(self.post("/api/rules/sign", fields)[1])["payload"]
object.__setattr__(self.httpd.hub, "offers", rules.Offers())
self.assertEqual(self.post("/api/rules", {"rule": unsigned, "assertion": signer.assertion(unsigned, self.origin, "localhost", PRESENT, 0), "enabled": True})[0], 409)
fresh = self.signed_rule(signer, fields)
self.assertEqual([stored["id"] for stored in self.httpd.hub.rules.listed()], [fresh["id"]])
with mock.patch.object(batches, "UNDO", 0.05):
asked = self.create_ask({**ASK, "command": "make x", "session": "s1"})
time.sleep(0.6)
self.assertEqual(self.ask_status(asked, "0"), "allowed")
def test_a_group_changed_after_signing_grants_nothing_beyond_the_signed_members(self):
self.claim("s3", "Evil")
self.snapshot()
signer = self.pin()
group = json.loads(self.post("/api/firewall/groups", {"name": "builders", "members": ["s1", "s2"]})[1])
self.signed_rule(signer, {"kind": "ask", "tool": "Bash", "pattern": "make *", "scope": "/repo*", "expires": time.time() + 3600, "agents": group["members"]})
self.assertEqual(self.call("POST", f"/api/firewall/groups/{group['id']}/delete", b"", self.guard(self.host))[0], 200)
self.assertEqual(self.post("/api/firewall/groups", {"name": "builders", "members": ["s1", "s2", "s3"]})[0], 201)
with mock.patch.object(batches, "UNDO", 0.05):
asks = {session: self.create_ask({**ASK, "command": "make x", "session": session}) for session in ("s1", "s3")}
time.sleep(0.6)
self.assertEqual({session: self.ask_status(ask_id, "0") for session, ask_id in asks.items()}, {"s1": "allowed", "s3": "pending"})
def test_the_signed_target_decides_and_an_untargeted_rule_reaches_every_agent(self):
now = time.time()
plain = signing.rule_payload("0123456789abcdef", ["ask"], "Bash", "make *", "*", int(now) + 600)
item = signing.ask_item("fedcba9876543210", "Bash", "make x", "/repo", "s2")
self.assertTrue(signing.rule_allows(plain, item, "", now))
self.assertTrue(signing.rule_allows(signing.targeted(plain, ["*"]), item, "", now))
self.assertTrue(signing.rule_allows(signing.targeted(plain, ["s1", "s2"]), item, "", now))
self.assertFalse(signing.rule_allows(signing.targeted(plain, ["s1"]), item, "", now))
review = signing.rule_payload("0123456789abcdef", ["review"], "", "*", "*", int(now) + 600)
commit = signing.review_item("fedcba9876543210", "/repo/.git", "/repo", "feature/x", "0" * 40)
self.assertTrue(signing.rule_allows(review, commit, "pass", now))
self.assertFalse(signing.rule_allows(signing.targeted(review, ["s1"]), commit, "pass", now))
for agents in ([], ["s2", "s1"], ["s1", "s1"], ["*", "s1"], "s1", [3]):
with self.subTest(agents=agents), self.assertRaises(signing.Refused):
signing.checked_rule(signing.targeted(plain, agents), now)
subject = {"recommended": "Yes", "agent": "Skills", "sessions": {"s1"}}
stored = {"kind": "decision", "pattern": "*", "enabled": True, "expires": now + 600}
targeted = {**stored, "proof": {"payload": signing.targeted(review, ["s2"])}}
self.assertFalse(rules.rule_matches(targeted, "decision", subject, now))
self.assertTrue(rules.rule_matches({**stored, "proof": {"payload": signing.targeted(review, ["s1"])}}, "decision", subject, now))
+8
View File
@@ -87,6 +87,14 @@ class TestHubGates(HubCase):
self.assertEqual(sorted((job["kind"], job["argv"], job["command"].split()[0]) for job in jobs), sorted(("gate", item["argv"], "gates.py") for item in items))
self.assertEqual(self.get("/api/gates")[0], 405)
def test_a_branch_or_repo_with_a_hidden_character_is_never_offered_for_a_signature(self):
for name, argv, code in (("bidi branch", rule("commit", "test", branch=f"feature/x{chr(0x202E)}"), "U+202E"), ("zero-width repo", rule("commit", "test", repo=f"{REPO}{chr(0x200B)}"), "U+200B"), ("Hangul filler branch", rule("commit", "test", branch=f"main{chr(0x3164)}"), "U+3164"), ("no-break space repo", rule("commit", "test", repo=f"{REPO}{chr(0xA0)}"), "U+00A0")):
with self.subTest(name=name):
self.assertEqual(signing.gate_argv(argv), argv)
status, _, body = self.post_json("/api/sign", {"items": self.stage([argv])}, self.guard(self.host))
self.assertEqual(status, 400)
self.assertIn(code, body.decode("utf-8"))
def test_the_hub_refuses_a_malformed_or_forged_gate_change_before_it_queues(self):
for name, items in (("receipt", self.stage([["receipt", "add", "--repo", REPO, "--tree", "a" * 40, "--level", "e2e", "--log", "/x"]])), ("own parent", self.stage([parent("feature/x")])), ("twice", self.stage([parent("main"), parent("main")])), ("extra key", [{"kind": "gate", "argv": parent("main"), "id": "x"}])):
with self.subTest(name=name):
+3 -2
View File
@@ -24,7 +24,7 @@ hub_limits = importlib.import_module("hub_limits")
approval = importlib.import_module("approval")
TEMPLATES = HUB / "templates"
DIFFS = TEMPLATES / "diffs.js"
PAGE_MODULES = ["page-constants.js", "page-dom.js", "page-diff.js", "page-inbox.js", "page-stream.js", "page-screens.js", "page-keyboard.js"]
PAGE_MODULES = ["page-constants.js", "page-reveal.js", "page-dom.js", "page-diff.js", "page-inbox.js", "page-stream.js", "page-screens.js", "page-keyboard.js"]
SECRET = 'api_key = "plain-example-words"'
ARMOURED = "before\n-----BEGIN EXAMPLE-----\nplain words only\n-----END EXAMPLE-----\nafter\n"
WITHHELD = "content withheld"
@@ -96,7 +96,8 @@ const document = {
querySelectorAll: () => [],
};
document.activeElement = document.body;
const all = (node) => (typeof node === "string" ? [] : [node, ...node.children.flatMap(all)]);
document.getElementById("emoji-bases").textContent = "[]";
const all =(node) => (typeof node === "string" ? [] : [node, ...node.children.flatMap(all)]);
const classes = (node) => String(node.className || node.attrs.class || "").split(" ").filter(Boolean);
const labels = (node) => all(node).filter((el) => el.tag === "button").map((el) => el.getAttribute("aria-label") || el.textContent);
const calls = {proofs: [], posts: [], sheets: [], radio: []};
+1 -1
View File
@@ -25,7 +25,7 @@ const sendJson = async () => {
const toast = (title) => toasts.push(title);
const bytes = new Uint8Array([1]).buffer;
const credential = {rawId: bytes, response: {clientDataJSON: bytes, authenticatorData: bytes, signature: bytes}};
const P = new Function("window", "navigator", "sendJson", "toast", "fail", "h", `${source}\\nreturn {signedProof};`)(window, navigator, sendJson, toast, () => [], () => null);
const P = new Function("window", "navigator", "sendJson", "toast", "fail", "h", "promptText", "document", `${source}\\nreturn {signedProof};`)(window, navigator, sendJson, toast, () => [], () => ({remove: () => {}}), (label) => label, {body: {append: () => {}}});
const tick = () => new Promise((resolve) => setImmediate(resolve));
const nonce = (signed) => (signed ? signed.proof.payload.nonce : null);
(async () => {
+18
View File
@@ -93,6 +93,24 @@ class TestHubReviews(HubCase):
self.assertEqual(self.tool("review_list", {})["structuredContent"]["reviews"], [])
self.assertEqual(list((self.state / "pages").iterdir()), [])
def test_a_review_with_a_look_alike_branch_title_or_path_is_refused_before_it_reaches_a_prompt(self):
source = self.page("bundle.html", PAGE)
plain = self.arguments("feat: x", "", source)
for name, value, code in (
("branch", f"main{chr(0x3164)}", "U+3164"),
("branch", f"main{chr(0x115F)}", "U+115F"),
("title", f"feat:{chr(0xA0)}x", "U+00A0"),
("title", f"feat: x{chr(0x34F)}", "U+034F"),
("worktree", f"/repo/.worktrees/x{chr(0xFE0F)}", "U+FE0F"),
("repo", f"/repo{chr(0xE0100)}/.git", "U+E0100"),
):
with self.subTest(name=name, code=code):
result = self.tool("review_request", {**plain, name: value})
self.assertTrue(result["isError"], result)
self.assertIn(code, json.dumps(result, ensure_ascii=True))
self.assertEqual(self.tool("review_list", {})["structuredContent"]["reviews"], [])
self.assertFalse(self.tool("review_request", plain).get("isError"))
def test_approve_flips_the_status_and_review_wait_returns_it(self):
review_id = self.request("feat: approve me", "")
results = []
+24 -2
View File
@@ -48,9 +48,9 @@ class TestHubRuleRequests(HubCase):
self.assertTrue(self.tool("rule_request", self.ask_rule(**change))["isError"])
for command, cwd in (("make test", "/repo"), ("make test-unit", "/repo/sub"), ("make deploy", "/repo"), ("make test && rm -rf /", "/repo"), ("make test", "/elsewhere")):
self.create_ask({**ASK, "command": command, "cwd": cwd})
request_id = self.requested(self.ask_rule())
item = self.item(request_id)
arguments = self.ask_rule()
request_id = self.requested(arguments)
item = self.item(request_id)
self.assertEqual({name: item["rule"][name] for name in ("kind", "tool", "pattern", "scope")}, {name: arguments[name] for name in ("kind", "tool", "pattern", "scope")})
self.assertEqual((item["agent"], item["detail"], item["green"], item["deniable"], item["dry_run"]), ("Skills", "the gate runs make test all day", False, True, {"matched": 2, "total": 5, "days": 7}))
self.assertEqual(self.waited(request_id), {"id": request_id, "status": "pending", "rule": None, "reason": "", "decided": None})
@@ -87,6 +87,28 @@ class TestHubRuleRequests(HubCase):
matched = self.create_ask({**ASK, "command": "make test"})
self.settle(lambda: self.ask_status(matched, "0") == "allowed")
def test_a_text_with_an_invisible_format_character_is_refused_before_it_reaches_a_prompt(self):
for change, code in (
({"pattern": f"make test{chr(0x202E)}*"}, "U+202E"),
({"pattern": f"make{chr(0x200B)} test*"}, "U+200B"),
({"scope": f"/repo{chr(0x2066)}*"}, "U+2066"),
({"tool": f"{chr(0xFEFF)}Bash"}, "U+FEFF"),
({"agent": f"Skills{chr(0x200D)}"}, "U+200D"),
):
with self.subTest(code=code):
result = self.tool("rule_request", self.ask_rule(**change))
self.assertTrue(result["isError"])
self.assertIn(code, json.dumps(result, ensure_ascii=True))
if "agent" not in change:
form = {name: self.ask_rule(**change)[name] for name in ("kind", "tool", "pattern", "scope", "expires")}
status, _, body = self.post_json("/api/rules/sign", form, self.guard(self.host))
self.assertEqual(status, 400)
self.assertIn(code, body.decode("utf-8"))
self.assertEqual([item for item in self.snapshot()["inbox"] if item["kind"] == "rule"], [])
self.assertEqual(self.httpd.hub.rule_requests.listed(), [])
request_id = self.requested(self.ask_rule())
self.assertEqual(self.item(request_id)["rule"]["pattern"], "make test*")
def test_review_and_decision_requests_count_their_own_history(self):
self.request("feat: green", "")
self.tool("review_request", {**self.arguments("feat: red", "", self.page("red.html", PAGE)), "gate": "fail"})
+1 -1
View File
@@ -136,7 +136,7 @@ class TestOrchestratorMigration(unittest.TestCase):
self.assertIn(f"{share / NEW}/client/permission_hook.py", hooks[1]["hooks"][0]["command"])
self.assertEqual(settings.stat().st_mode & 0o777, 0o640)
self.assertIn(f"{OLD}/client", (self.home / ".claude" / f"settings.json.before-{NEW}-migration").read_text(encoding="utf-8"))
self.assertEqual((first["images"], first["mcp"], first["enabled"]), ([f"{NEW}:local"], {NEW: "http://127.0.0.1:8737/mcp"}, [f"{NEW}-offices.path", f"{NEW}-resources.timer", f"{NEW}-runner.service", f"{NEW}-sessions.timer"]))
self.assertEqual((first["images"], first["mcp"], first["enabled"]), ([f"{NEW}:local"], {NEW: "http://127.0.0.1:8737/mcp"}, [f"{NEW}-firewall.path", f"{NEW}-firewall.timer", f"{NEW}-offices.path", f"{NEW}-resources.timer", f"{NEW}-runner.service", f"{NEW}-sessions.timer"]))
self.assertIn(["docker", "compose", "--file", str(share / OLD / "compose.yml"), "down", "--remove-orphans"], first["calls"])
before = snapshot(self.home)
+106
View File
@@ -0,0 +1,106 @@
from __future__ import annotations
import json
import shutil
import subprocess
import tempfile
import time
import unittest
from pathlib import Path
TEMPLATES = Path(__file__).resolve().parent.parent / "orchestrator" / "templates"
FIREWALL = TEMPLATES / "page-firewall.js"
REVEAL = TEMPLATES / "page-reveal.js"
NOW = 1_800_000_000
DAY = 86400
NAMES = {"s1": "Skills", "s2": "Stage", "s3": "Evil"}
HARNESS = """const fs = require("fs");
const [source, given] = [fs.readFileSync(process.argv[2], "utf8"), JSON.parse(fs.readFileSync(process.argv[3], "utf8"))];
const revealed = new Function("document", `${fs.readFileSync(process.argv[4], "utf8")}\\nreturn revealed;`)({getElementById: () => ({textContent: "[]"})});
const make = new Function("HUMAN", "people", "labelOf", "h", "state", "nowSeconds", "DAY", "revealed", `${source}\\nreturn {scopeLabel, promptText: typeof promptText === "function" ? promptText : () => "no promptText", firewall};`);
const page = make("human", () => given.names, (key) => given.names[key] || key, () => ({}), {rules: []}, () => given.now, given.day, revealed);
page.firewall.data = {groups: given.groups, files: [], sets: []};
console.log(JSON.stringify({scope: given.scopes.map((agents) => page.scopeLabel(agents)), prompts: given.prompts.map(([label, prepared]) => page.promptText(label, prepared))}));
"""
def rule(agents: list[str] | None, days: int) -> dict:
"""Returns:
A signed rule payload for asks of any command under /home/op, lasting
days from NOW, for agents or, with None, untargeted.
"""
payload = {"v": 1, "kind": "rule", "id": "0123456789abcdef", "kinds": ["ask"], "tool": "Bash", "pattern": "*", "scope": "/home/op/*", "expires": NOW + days * DAY}
return payload if agents is None else {**payload, "agents": agents}
def shown(source: Path, groups: list[dict], scopes: list[list[str]], prompts: list[list[object]], names: dict[str, str]) -> dict:
"""Args:
source: the page script.
groups: the firewall groups the page knows.
scopes: the agents of each scope to name.
prompts: each [label, offer] to show in the passkey prompt.
names: the label of each session, as council claims give it.
Returns:
{"scope", "prompts"}: what the page script names for each scope and
shows in the passkey prompt for each [label, offer].
"""
with tempfile.TemporaryDirectory() as scratch:
harness, given = Path(scratch) / "harness.js", Path(scratch) / "given.json"
harness.write_text(HARNESS, encoding="utf-8")
given.write_text(json.dumps({"names": names, "now": NOW, "day": DAY, "groups": groups, "scopes": scopes, "prompts": prompts}), encoding="utf-8")
done = subprocess.run(["node", str(harness), str(source), str(given), str(REVEAL)], capture_output=True, text=True, timeout=60, check=False)
if done.returncode != 0:
raise AssertionError(done.stderr.strip()[:500])
return json.loads(done.stdout)
@unittest.skipUnless(shutil.which("node"), "no node")
class TestPagePrompt(unittest.TestCase):
def test_a_group_redefined_after_it_was_picked_shows_every_signed_session(self):
redefined = [{"id": "ffffffffffffffff", "name": "builders", "members": ["s1", "s2", "s3"]}]
found = shown(FIREWALL, redefined, [["s1", "s2", "s3"], ["s1", "s2"], ["s3"], ["*"]], [], NAMES)
self.assertEqual(found["scope"], ["for group builders: Skills (s1), Stage (s2), Evil (s3)", "for agents Skills (s1), Stage (s2)", "for agent Evil (s3)", "for all agents"])
def test_the_prompt_shows_the_pattern_directory_and_lifetime_of_every_signed_rule(self):
end = time.strftime("%Y-%m-%d %H:%M", time.gmtime(NOW + 366 * DAY))
approval = {"v": 1, "kind": "approve", "items": ["ab" * 32], "nonce": "cd" * 16, "expires": NOW + 900}
found = shown(FIREWALL, [], [], [
["Rule set ci", {"payload": rule(["s1"], 366)}],
["Rule", {"payload": rule(None, 1)}],
["Turn on rule", {"payload": approval, "enables": rule(["s1", "s3"], 366)}],
["Settings", {"payload": approval}],
], NAMES)
lines = ["ask Bash: *", "in /home/op/*", f"until {end} UTC, in 366.0 days"]
self.assertEqual([prompt.split("\n") for prompt in found["prompts"]], [
["Rule set ci", *lines, "for agent Skills (s1)"],
["Rule", "ask Bash: *", "in /home/op/*", f"until {time.strftime('%Y-%m-%d %H:%M', time.gmtime(NOW + DAY))} UTC, in 1.0 days", "for all agents"],
["Turn on rule", *lines, "for agents Skills (s1), Evil (s3)"],
["Settings"],
])
def test_a_hidden_character_of_a_group_set_claim_legacy_rule_or_pattern_shows_as_a_marker_in_the_prompt(self):
rlo, separator, nel = chr(0x202E), chr(0x2028), chr(0x85)
approval = {"v": 1, "kind": "approve", "items": ["ab" * 32], "nonce": "cd" * 16, "expires": NOW + 900}
groups = [{"id": "ffffffffffffffff", "name": f"ci{rlo}", "members": ["s1", "s3"]}]
legacy = {**rule(None, 1), "pattern": f"make test{rlo}*"}
separated = {**rule(["s2"], 1), "pattern": f"make test{separator}in /safe", "scope": f"/repo{nel}*"}
found = shown(FIREWALL, groups, [], [
[f"Rule set ci{rlo}", {"payload": rule(["s1", "s3"], 1)}],
["Turn on rule", {"payload": approval, "enables": legacy}],
["Rule", {"payload": separated}],
], {**NAMES, "s2": f"Main{rlo}"})
until = f"until {time.strftime('%Y-%m-%d %H:%M', time.gmtime(NOW + DAY))} UTC, in 1.0 days"
self.assertEqual([prompt.split("\n") for prompt in found["prompts"]], [
[f"Rule set ci{marker(0x202E)}", "ask Bash: *", "in /home/op/*", until, f"for group ci{marker(0x202E)}: Skills (s1), Evil (s3)"],
["Turn on rule", f"ask Bash: make test{marker(0x202E)}*", "in /home/op/*", until, "for all agents"],
["Rule", f"ask Bash: make test{marker(0x2028)}in /safe", f"in /repo{marker(0x85)}*", until, f"for agent Main{marker(0x202E)} (s2)"],
])
def marker(code: int) -> str:
return f"⟨U+{code:04X}⟩"
if __name__ == "__main__":
unittest.main()
+182
View File
@@ -0,0 +1,182 @@
from __future__ import annotations
import json
import shutil
import subprocess
import tempfile
import unittest
from pathlib import Path
from hub_support import signing
TEMPLATES = Path(__file__).resolve().parent.parent / "orchestrator" / "templates"
MODULES = ["page-constants.js", "ancestry.js", "page-reveal.js", "page-dom.js", "page-diff.js", "page-rule-request.js", "page-inbox.js", "page-firewall.js", "page-review.js", "page-cleanup.js", "page-offices.js", "page-ancestry.js", "page-tasks-prio.js"]
RLO, ZWSP, LRI, SEPARATOR, CARRIAGE = chr(0x202E), chr(0x200B), chr(0x2066), chr(0x2028), chr(0x0D)
FILLER, NBSP, CGJ, VS15, VS16 = chr(0x3164), chr(0xA0), chr(0x34F), chr(0xFE0E), chr(0xFE0F)
HIDDEN = (RLO, ZWSP, LRI, SEPARATOR, CARRIAGE, FILLER, NBSP, CGJ, VS16)
STOPWATCH, SHIELD, HEART = chr(0x23F1), chr(0x1F6E1), chr(0x2764)
CONTEXTS = (
("score line", f"🎯 fix 93 · {STOPWATCH}{VS16} time 20 · {SHIELD}{VS16} security 100", True),
("text presentation", f"{STOPWATCH}{VS15} 20", True),
("heart", f"thanks {HEART}{VS16}", True),
("stacked selectors", f"{STOPWATCH}{VS16}{VS16} 20", False),
("joiner after a sequence", f"{SHIELD}{VS16}{chr(0x200D)}", False),
("leading selector", f"{VS16}stop {STOPWATCH}", False),
("ASCII letter", f"a{VS16}", False),
("combining mark", f"e{chr(0x301)}{VS16}", False),
("keycap", f"1{VS16}{chr(0x20E3)}", False),
("number sign", f"#{VS16}", False),
("command", f"make test{VS16}", False),
("emoji without a sequence", f"🎯{VS16}", False),
("other selector", f"{STOPWATCH}{chr(0xFE00)}", False),
("no-break space", f"rm{NBSP}-rf", False),
("Hangul filler", f"main{FILLER}", False),
)
HARNESS = r"""const fs = require("fs");
const [dir, given] = [process.argv[2], JSON.parse(fs.readFileSync(process.argv[3], "utf8"))];
const source = given.files.map((name) => fs.readFileSync(`${dir}/${name}`, "utf8")).join("\n");
class FakeNode {
constructor(tag) { this.tag = tag; this.attrs = {}; this.children = []; }
setAttribute(key, value) { this.attrs[key] = value; }
append(...children) { this.children.push(...children); }
replaceChildren(...children) { this.children = children; }
addEventListener() {}
focus() {}
get value() { return this.attrs.value ?? ""; }
}
const stub = new Proxy(function () {}, {get: (target, key) => (key === Symbol.toPrimitive ? () => "" : key === Symbol.iterator ? [][Symbol.iterator].bind([]) : stub), apply: () => stub});
const sheet = new FakeNode("div");
const provided = {document: {createElement: (tag) => new FakeNode(tag), createElementNS: (ns, tag) => new FakeNode(tag), getElementById: (id) => (id === "emoji-bases" ? {textContent: JSON.stringify(given.bases)} : sheet), addEventListener() {}}, Node: FakeNode, ...given.globals};
const scope = new Proxy({}, {has: (target, key) => typeof key === "string" && (key in provided || !(key in globalThis)), get: (target, key) => (key === Symbol.unscopables ? undefined : key in provided ? provided[key] : stub)});
const page = new Function("scope", `with (scope) {\n${source}\nreturn {${given.calls.map(([name]) => name).join(", ")}};\n}`)(scope);
const own = (node) => [node.attrs.title, node.textContent].filter((text) => typeof text === "string");
const texts = (node) => (typeof node === "string" ? [node] : Array.isArray(node) ? node.flatMap(texts) : node instanceof FakeNode ? [...own(node), ...node.children.flatMap(texts)] : []);
console.log(JSON.stringify(given.calls.map(([name, args]) => {
const drawn = page[name](...args);
return texts(drawn === undefined ? sheet : drawn);
})));
"""
PROBE = r"""const fs = require("fs");
const given = JSON.parse(fs.readFileSync(process.argv[2], "utf8"));
const revealed = new Function("document", `${fs.readFileSync(process.argv[1], "utf8")}\nreturn revealed;`)({getElementById: () => ({textContent: JSON.stringify(given.bases)})});
console.log(JSON.stringify(given.texts.map(revealed)));
"""
def shown(templates: Path, calls: list[list[object]], globals_: dict | None = None) -> list[list[str]]:
"""Args:
templates: the folder of the page modules.
calls: each [function, arguments] of the page to render.
globals_: page state the calls read, such as state, ui and tree.
Returns:
Every text, text content and title each rendered node shows, or the
sheet a call opens, in order.
"""
with tempfile.TemporaryDirectory() as scratch:
harness, given = Path(scratch) / "harness.js", Path(scratch) / "given.json"
harness.write_text(HARNESS, encoding="utf-8")
given.write_text(json.dumps({"files": MODULES, "calls": calls, "globals": globals_ or {}, "bases": sorted(signing.EMOJI_BASES)}), encoding="utf-8")
done = subprocess.run(["node", str(harness), str(templates), str(given)], capture_output=True, text=True, timeout=60, check=False)
if done.returncode != 0:
raise AssertionError(done.stderr.strip()[:800])
return json.loads(done.stdout)
def item(kind: str, **fields: object) -> dict:
base = {"kind": kind, "id": "0123456789abcdef", "title": "Bash: make test", "command": "", "directory": "", "agent": "Skills", "to": "Skills", "ts": 1_800_000_000, "warnings": [], "options": [], "recommended": "", "held": False, "until": 0, "pinned": False, "diff": None, "job": None, "rule": None, "detail": "", "green": False, "gate": "", "score": "", "runnable": True, "deniable": True, "sha256": ""}
return {**base, **fields}
@unittest.skipUnless(shutil.which("node"), "no node")
class TestPageReveal(unittest.TestCase):
def assertRevealed(self, texts: list[str], codes: list[str]) -> None:
joined = "\n".join(texts)
for char in HIDDEN:
self.assertNotIn(char, joined)
for code in codes:
self.assertIn(f"⟨U+{code}⟩", joined)
def test_the_sink_marks_every_control_format_separator_and_ignorable_character_but_the_tab(self):
probe = "".join(chr(code) for code in (0x202E, 0x200B, 0x2028, 0x2029, 0x85, 0x0B, 0x0D, 0x0A, 0x34F, 0xFE0F, 0x3164, 0xE0041, 0xAD, 0xA0, 0x3000))
found = shown(TEMPLATES, [["revealed", [f"a{probe}\tb ✓"]], ["revealedLines", [f"one{NBSP}\ntwo"]]])
self.assertEqual(found, [["a⟨U+202E⟩⟨U+200B⟩⟨U+2028⟩⟨U+2029⟩⟨U+0085⟩⟨U+000B⟩⟨U+000D⟩⟨U+000A⟩⟨U+034F⟩⟨U+FE0F⟩⟨U+3164⟩⟨U+E0041⟩⟨U+00AD⟩⟨U+00A0⟩⟨U+3000⟩\tb ✓"], ["one⟨U+00A0⟩\ntwo"]])
def test_both_sinks_accept_exactly_an_emoji_variation_sequence(self):
with tempfile.TemporaryDirectory() as scratch:
given = Path(scratch) / "given.json"
given.write_text(json.dumps({"bases": sorted(signing.EMOJI_BASES), "texts": [text for _, text, _ in CONTEXTS]}), encoding="utf-8")
done = subprocess.run(["node", "-e", PROBE, str(TEMPLATES / "page-reveal.js"), str(given)], capture_output=True, text=True, timeout=60, check=True)
for (name, text, accepted), page in zip(CONTEXTS, json.loads(done.stdout), strict=True):
with self.subTest(name=name):
self.assertEqual(signing.hidden_problem({"command": text}, "value") is None, accepted)
self.assertEqual(page == text, accepted)
self.assertEqual("⟨U+" in page, not accepted)
def test_the_variation_table_names_its_source_and_holds_no_ascii_base(self):
table = json.loads(signing.EMOJI_TABLE.read_text(encoding="utf-8"))
self.assertEqual(sorted(table), ["bases", "source", "unicode"])
self.assertEqual(table["source"], f"https://www.unicode.org/Public/{table['unicode']}/ucd/emoji/emoji-variation-sequences.txt")
self.assertEqual(min(signing.EMOJI_BASES), 0xA9)
self.assertLessEqual({0x23F1, 0x1F6E1, 0x2764, 0x26A0}, signing.EMOJI_BASES)
def test_a_variation_table_with_a_wrong_base_stops_the_load(self):
with tempfile.TemporaryDirectory() as scratch:
path = Path(scratch) / "emoji-variation.json"
for name, bases in (("short ASCII base", ["41"]), ("number sign base", ["0023"]), ("digit base", ["0031"]),("string value", "23F1"), ("object value", {"23F1": 1}), ("number", [0x23F1]), ("C1 control", ["009B"]), ("joiner", ["200D"]), ("surrogate", ["D800"]), ("lower case", ["23f1"])):
with self.subTest(name=name):
path.write_text(json.dumps({"bases": bases}), encoding="utf-8")
with self.assertRaises(ValueError):
signing.variation_table(path)
path.write_text(json.dumps({"bases": ["23F1", "1F6E1"]}), encoding="utf-8")
self.assertEqual(signing.variation_table(path), {0x23F1, 0x1F6E1})
path.unlink()
with self.assertRaises(OSError):
signing.variation_table(path)
def test_a_review_cleanup_office_ancestry_and_task_preview_show_every_look_alike_character_as_a_marker(self):
review = {"id": "r1", "title": f"feat: x{RLO}", "notes": f"score{NBSP}90\nline{CGJ}", "created_ts": 1_800_000_000, "worktree": "/repo/.worktrees/x", "branch": f"main{FILLER}", "tree": "a" * 40, "gate": "pass", "score": f"🎯{VS16} 90", "status": "pending"}
repo = {"path": "/r", "name": "skills", "branches": [{"name": f"main{FILLER}", "plan": [f"git branch -D main{FILLER}"], "held": None}, {"name": "feature/a", "plan": [], "held": None}]}
page_state = {
"state": {"reviews": [review], "inbox": [], "jobs": [{"kind": "task", "task": "T1", "command": f"rasci.py set T1{RLO} --prio 3", "status": "done"}], "graph": {"nodes": []}, "claims": []},
"ui": {"review": None, "file": 0},
"tree": {"data": {"repos": [repo], "gates": {"/r": {"feature/a": {"parents": [{"parent": f"main{FILLER}", "source": "own"}], "rules": {}}}}}},
}
calls = [
["reviewSheet", ["r1"]],
["deleteDialog", [[{"repository": "/r", "branch": f"main{FILLER}", "tip": "b" * 40}]]],
["officeSheet", ["takeover", {"office": f"work/x{FILLER}", "session": "s1", "work": "-"}]],
["branchAncestry", [repo]],
["priorityForm", [{"task": f"T1{FILLER}", "estimates": {}, "prio": 3}]],
["taskJobs", [{"task": "T1"}]],
]
found = shown(TEMPLATES, calls, page_state)
self.assertRevealed(found[0], ["202E", "3164", "00A0", "034F", "FE0F"])
for drawn in found[1:5]:
self.assertRevealed(drawn, ["3164"])
self.assertRevealed(found[5], ["202E"])
def test_an_inbox_ask_operator_row_and_decision_show_every_hidden_character_as_a_marker(self):
ask = item("ask", command=f"git status{RLO} && rm -rf ~", directory=f"/repo{ZWSP}", agent=f"Skills{RLO}")
operator = item("operator", id="operator/run", title=f"make{CARRIAGE} test", command=f"make{CARRIAGE} test", directory=f"/repo{LRI}", detail=f"why{SEPARATOR}not")
decision = item("decision", title=f"Merge{RLO}?", options=[{"label": f"Merge now{RLO}", "description": f"Gate{ZWSP} is green"}], recommended=f"Merge now{RLO}")
found = shown(TEMPLATES, [["inboxItem", [ask, 0]], ["inboxItem", [operator, 1]], ["inboxItem", [decision, 2]]])
self.assertRevealed(found[0], ["202E", "200B"])
self.assertRevealed(found[1], ["000D", "2066", "2028"])
self.assertRevealed(found[2], ["202E", "200B"])
def test_a_diff_row_and_a_rule_request_show_every_hidden_character_as_a_marker(self):
rule = item("rule", detail=f"needed{ZWSP} daily", rule={"kind": "ask", "tool": "Bash", "pattern": f"make test{RLO}*", "scope": f"/repo{SEPARATOR}*", "expires": 1_800_000_000}, dry_run={"matched": 0, "total": 0, "days": 7})
found = shown(TEMPLATES, [["patchRow", [{"kind": "add", "old": None, "new": 3, "text": f"access = 'user'{RLO} # admin"}]], ["ruleRequestBody", [rule]]])
self.assertRevealed(found[0], ["202E"])
self.assertRevealed(found[1], ["200B", "202E", "2028"])
def test_a_settings_entry_staged_for_removal_and_its_diff_show_every_hidden_character_as_a_marker(self):
entry = f"Read(~/.ssh/**{RLO})"
found = shown(TEMPLATES, [["entryRow", ["/home/op/.claude/settings.json", "permissions.deny", entry]], ["diffLines", [f'- "{entry}",\n+ "Bash(make{ZWSP} build:*)"']]])
self.assertRevealed(found[0], ["202E"])
self.assertRevealed(found[1], ["202E", "200B"])
if __name__ == "__main__":
unittest.main()
+75
View File
@@ -0,0 +1,75 @@
from __future__ import annotations
import re
import shutil
import subprocess
import tempfile
import unittest
from collections import defaultdict
from pathlib import Path
TEMPLATES = Path(__file__).resolve().parent.parent / "orchestrator" / "templates"
INCLUDE = re.compile(r'\{% include "([^"]+\.js)" %\}')
DECLARED = re.compile(r"^ (?:async\s+)?(?:function\s*\*?\s*([A-Za-z_$][\w$]*)|(?:const|let|var|class)\s+([A-Za-z_$][\w$]*))", re.MULTILINE)
OPENING = '(() => {\n "use strict";'
CLOSING = "})();"
def page_block(templates: Path) -> str:
"""Returns:
The shared page script of index.html.j2, from its opening arrow to
its closing call, with the include tags still in place.
"""
page = (templates / "index.html.j2").read_text(encoding="utf-8")
start = page.index(OPENING)
return page[start : page.index(CLOSING, start) + len(CLOSING)]
def clashes(templates: Path) -> dict[str, list[str]]:
"""Returns:
Every top-level name the shared page script declares in more than one
included file, with those files in include order.
"""
owners: dict[str, list[str]] = defaultdict(list)
for name in INCLUDE.findall(page_block(templates)):
for match in DECLARED.finditer((templates / name).read_text(encoding="utf-8")):
owners[match.group(1) or match.group(2)].append(name)
return {name: files for name, files in owners.items() if len(files) > 1}
def assembled(templates: Path) -> str:
return INCLUDE.sub(lambda match: (templates / match.group(1)).read_text(encoding="utf-8"), page_block(templates))
def parse_error(script: str) -> str:
"""Returns:
What node --check reports for the script, "" when it parses.
"""
with tempfile.TemporaryDirectory() as scratch:
path = Path(scratch) / "page.js"
path.write_text(script, encoding="utf-8")
done = subprocess.run(["node", "--check", str(path)], capture_output=True, text=True, timeout=60, check=False)
return "" if done.returncode == 0 else done.stderr.strip()[:500]
class TestPageScope(unittest.TestCase):
def test_no_top_level_name_is_declared_in_two_page_files(self):
self.assertEqual(clashes(TEMPLATES), {})
@unittest.skipUnless(shutil.which("node"), "no node")
def test_the_assembled_page_script_parses(self):
self.assertEqual(parse_error(assembled(TEMPLATES)), "")
def test_a_clash_between_two_page_files_is_caught(self):
with tempfile.TemporaryDirectory() as scratch:
copy = Path(scratch)
shutil.copytree(TEMPLATES, copy, dirs_exist_ok=True)
firewall = copy / "page-firewall.js"
firewall.write_text(firewall.read_text(encoding="utf-8") + "\n const pickOf = (key) => key;\n", encoding="utf-8")
self.assertEqual(clashes(copy), {"pickOf": ["page-firewall.js", "page-popup.js"]})
if shutil.which("node"):
self.assertIn("'pickOf' has already been declared", parse_error(assembled(copy)))
if __name__ == "__main__":
unittest.main()
+504
View File
@@ -0,0 +1,504 @@
from __future__ import annotations
import contextlib
import errno
import hashlib
import importlib.util
import io
import json
import os
import secrets
import stat
import subprocess
import sys
import tempfile
import time
import unittest
from pathlib import Path
from unittest import mock
import test_hub_spool_links as spool_links
from hub_support import HUB, ORIGIN, key, signing, verifier
WRITER = HUB / "client" / "settings_writer.py"
WRITER_SPEC = importlib.util.spec_from_file_location("kvb_orchestrator_settings_writer", WRITER)
host = importlib.util.module_from_spec(WRITER_SPEC)
WRITER_SPEC.loader.exec_module(host)
ORIGINAL = {
"model": "x",
"env": {"EXAMPLE_FLAG": "fixture-value-not-a-secret"},
"hooks": {"Stop": [{"matcher": "", "hooks": [{"type": "command", "command": "true"}]}]},
"permissions": {"allow": ["Bash(make test:*)", "Bash(git status:*)"], "deny": ["Read(~/.ssh/**)"]},
"sandbox": {"enabled": True, "filesystem": {"allowWrite": ["/tmp"]}},
}
ADD_LINT = {"list": "permissions.allow", "op": "add", "entry": "Bash(make lint:*)"}
def sha(data: bytes) -> str:
return hashlib.sha256(data).hexdigest()
class TestSettingsWriter(unittest.TestCase):
def setUp(self):
tmp = tempfile.TemporaryDirectory()
self.addCleanup(tmp.cleanup)
self.base = Path(tmp.name)
self.home = self.base / "home"
self.settings = self.home / ".claude" / "settings.json"
self.project = self.base / "repo"
self.project_settings = self.project / ".claude" / "settings.json"
self.elsewhere = self.base / "elsewhere" / ".claude" / "settings.json"
for path in (self.settings, self.elsewhere):
path.parent.mkdir(parents=True)
path.write_text(json.dumps(ORIGINAL, indent=2) + "\n", encoding="utf-8")
path.chmod(0o640)
self.project_settings.parent.mkdir(parents=True)
self.tree = self.base / "tree" / "branch-tree.json"
self.tree.parent.mkdir()
self.tree.write_text(json.dumps({"repos": [{"path": str(self.project), "known": True, "default": "main"}, {"path": str(self.elsewhere.parent.parent), "known": False}]}), encoding="utf-8")
self.jobs, self.results = self.base / "jobs", self.base / "results"
self.jobs.mkdir(mode=0o700)
self.results.mkdir(mode=0o700)
self.approvers = self.base / "config" / "approvers.json"
self.trust = verifier.Trust(approvers=self.approvers, replay=self.base / "replay" / "firewall.json", origin=ORIGIN)
self.signer = key(-7, "main")
self.signer.pin(self.approvers, ORIGIN)
self.writer = host.Writer(self.trust, self.home, self.tree)
def item(self, path: Path, changes: list[dict]) -> dict:
return {"file": str(path), "base": sha(path.read_bytes()) if path.exists() else "", "changes": changes}
def proof(self, items: list[dict], signer) -> dict:
hashes = [signing.item_hash(signing.settings_item(**item)) for item in items]
return signer.proof(signing.approval_payload(hashes, secrets.token_hex(16), int(time.time()) + 600), ORIGIN)
def write_job(self, job_id: str, items: list[dict], proof: object) -> None:
(self.jobs / f"{job_id}.json").write_text(json.dumps({"v": 1, "id": job_id, "created": "x", "items": items, "proof": proof}), encoding="utf-8")
def result(self, job_id: str) -> dict:
return json.loads((self.results / f"{job_id}.json").read_text(encoding="utf-8"))
def run_job(self, items: list[dict], proof: object) -> dict:
job_id = secrets.token_hex(8)
self.write_job(job_id, items, proof)
self.assertEqual(host.cycle(self.jobs, self.results, self.writer), 1)
self.assertEqual(list(self.jobs.iterdir()), [])
return self.result(job_id)
def unit(self, view: Path, marker: dict[str, str]) -> subprocess.CompletedProcess:
trust = ["--approvers", str(self.approvers), "--replay", str(self.trust.replay)]
command = [sys.executable, str(WRITER), "--port", ORIGIN.rsplit(":", 1)[1], "--jobs", str(self.jobs), "--results", str(self.results), "--view", str(view), *trust, "--tree", str(self.tree)]
return subprocess.run(command, capture_output=True, text=True, timeout=60, check=False, env={"PATH": "/usr/bin:/bin", "HOME": str(self.home), **marker})
def signed(self, item: dict) -> dict:
return self.run_job([item], self.proof([item], self.signer))["items"][0]
def files(self) -> dict[str, tuple[int, str]]:
found = {}
for root in (self.home, self.project, self.elsewhere.parent.parent):
for path in sorted(root.rglob("*")):
if path.is_file() or path.is_symlink():
found[str(path)] = (path.lstat().st_mode, sha(path.read_bytes()) if path.is_file() else os.readlink(path))
return found
def test_a_signed_change_writes_exactly_it_keeps_every_other_key_and_a_backup_with_the_mode(self):
before = self.settings.read_bytes()
changes = [ADD_LINT, {"list": "permissions.deny", "op": "remove", "entry": "Read(~/.ssh/**)"}, {"list": "sandbox.network.allowedDomains", "op": "add", "entry": "example.org"}]
result = self.signed(self.item(self.settings, changes))
self.assertEqual((result["status"], result["reason"]), ("done", ""), result)
expected = json.loads(json.dumps(ORIGINAL))
expected["permissions"]["allow"].append("Bash(make lint:*)")
expected["permissions"]["deny"] = []
expected["sandbox"]["network"] = {"allowedDomains": ["example.org"]}
written = self.settings.read_bytes()
self.assertEqual(json.loads(written), expected)
self.assertEqual(list(json.loads(written)), list(ORIGINAL))
self.assertEqual(result["sha256"], sha(written))
backup = Path(result["backup"])
self.assertEqual((backup.parent, backup.read_bytes()), (self.settings.parent, before))
self.assertEqual({path.name: path.stat().st_mode & 0o777 for path in self.settings.parent.iterdir()}, {"settings.json": 0o640, backup.name: 0o640})
def test_a_missing_project_file_is_created_private_with_only_the_change(self):
result = self.signed(self.item(self.project_settings, [ADD_LINT]))
self.assertEqual((result["status"], result["backup"]), ("done", ""), result)
self.assertEqual(json.loads(self.project_settings.read_text(encoding="utf-8")), {"permissions": {"allow": ["Bash(make lint:*)"]}})
self.assertEqual(self.project_settings.stat().st_mode & 0o777, 0o600)
def test_a_forged_changed_stale_unlisted_or_impossible_job_changes_nothing(self):
good = self.item(self.settings, [ADD_LINT])
rule = self.signer.proof(signing.rule_payload(secrets.token_hex(8), ["settings"], "", "*", "*", int(time.time()) + 600), ORIGIN)
swapped = {**good, "changes": [{**ADD_LINT, "entry": "Bash(rm -rf:*)"}]}
stale = {**good, "base": sha(b"{}")}
unlisted = self.item(self.elsewhere, [ADD_LINT])
twice = self.item(self.settings, [{**ADD_LINT, "entry": "Bash(make test:*)"}])
absent = self.item(self.settings, [{**ADD_LINT, "op": "remove"}])
cases = (
("forged signature", good, self.proof([good], key(-7, "intruder")), "no valid operator signature"),
("missing signature", good, None, "no signature"),
("rule instead of an approval", good, rule, "no valid operator signature"),
("changed after signing", swapped, self.proof([good], self.signer), "does not list this item"),
("stale base", stale, self.proof([stale], self.signer), "changed since the signature"),
("unlisted file", unlisted, self.proof([unlisted], self.signer), "unlisted file"),
("added twice", twice, self.proof([twice], self.signer), "lists Bash(make test:*)"),
("removed absent", absent, self.proof([absent], self.signer), "does not list"),
)
for name, item, proof, reason in cases:
with self.subTest(name=name):
before = self.files()
result = self.run_job([item], proof)["items"][0]
self.assertEqual(result["status"], "refused", result)
self.assertIn(reason, result["reason"])
self.assertEqual(self.files(), before)
def test_the_host_refuses_to_add_a_hidden_character_and_removes_one_already_in_the_file(self):
hidden = f"Bash(make{chr(0x202E)} build:*)"
before = self.files()
addition = self.item(self.settings, [{**ADD_LINT, "entry": hidden}])
self.assertEqual(self.run_job([addition], self.proof([addition], self.signer))["error"], "malformed job: refused, nothing changed")
self.assertEqual(self.files(), before)
settings = json.loads(self.settings.read_text(encoding="utf-8"))
settings["permissions"]["allow"].append(hidden)
self.settings.write_text(json.dumps(settings, indent=2) + "\n", encoding="utf-8")
result = self.signed(self.item(self.settings, [{"list": "permissions.allow", "op": "remove", "entry": hidden}]))
self.assertEqual(result["status"], "done", result)
self.assertEqual(json.loads(self.settings.read_text(encoding="utf-8"))["permissions"]["allow"], ORIGINAL["permissions"]["allow"])
def test_a_replayed_signature_changes_nothing_even_when_the_file_is_back_at_its_base(self):
before = self.settings.read_bytes()
item = self.item(self.settings, [ADD_LINT])
proof = self.proof([item], self.signer)
self.assertEqual(self.run_job([item], proof)["items"][0]["status"], "done")
self.settings.write_bytes(before)
again = self.run_job([item], proof)["items"][0]
self.assertEqual(again["status"], "refused")
self.assertIn("already used", again["reason"])
self.assertEqual(self.settings.read_bytes(), before)
def test_a_link_on_the_path_or_at_the_file_is_refused(self):
outside = self.base / "outside"
(outside / ".claude").mkdir(parents=True)
target = outside / ".claude" / "settings.json"
target.write_text("{}\n", encoding="utf-8")
self.project_settings.parent.rmdir()
(self.project / ".claude").symlink_to(outside / ".claude")
result = self.signed({"file": str(self.project_settings), "base": sha(b"{}\n"), "changes": [ADD_LINT]})
self.assertEqual(result["status"], "refused", result)
self.assertIn("link", result["reason"])
(self.project / ".claude").unlink()
(self.project / ".claude").mkdir()
self.project_settings.symlink_to(target)
result = self.signed({"file": str(self.project_settings), "base": sha(b"{}\n"), "changes": [ADD_LINT]})
self.assertEqual(result["status"], "refused", result)
self.assertIn("link", result["reason"])
self.assertEqual((target.read_text(encoding="utf-8"), self.project_settings.is_symlink()), ("{}\n", True))
def test_a_failed_replace_keeps_the_file_and_leaves_no_temporary(self):
before = self.settings.read_bytes()
replace = os.replace
def failing(source: str, target: str, **kwargs: int) -> None:
if target == "settings.json":
raise OSError(errno.EIO, "disk gone")
replace(source, target, **kwargs)
with mock.patch.object(host.os, "replace", failing):
result = self.signed(self.item(self.settings, [ADD_LINT]))
self.assertEqual(result["status"], "failed", result)
self.assertEqual(self.settings.read_bytes(), before)
self.assertEqual(sorted(path.name for path in self.settings.parent.iterdir() if path.name.startswith(".")), [])
def test_a_malformed_or_linked_job_writes_nothing(self):
good = self.item(self.settings, [ADD_LINT])
before = self.files()
for name, items in (
("command smuggled in", [{**good, "command": "rm -rf ~"}]),
("local settings", [{**good, "file": str(self.settings.with_name("settings.local.json"))}]),
("climbing path", [{**good, "file": f"{self.home}/../home/.claude/settings.json"}]),
("no changes", [{**good, "changes": []}]),
("hooks list", [{**good, "changes": [{**ADD_LINT, "list": "hooks.PermissionRequest"}]}]),
("replace op", [{**good, "changes": [{**ADD_LINT, "op": "replace"}]}]),
("two lines", [{**good, "changes": [{**ADD_LINT, "entry": "a\nb"}]}]),
("lone surrogate entry", [{**good, "changes": [{**ADD_LINT, "entry": "Bash(make \ud800:*)"}]}]),
("lone surrogate path", [{**good, "file": f"{self.home}/\ud800/.claude/settings.json"}]),
("twice the same entry", [{**good, "changes": [ADD_LINT, ADD_LINT]}]),
("no items", []),
):
with self.subTest(name=name):
result = self.run_job(items, self.proof([good], self.signer))
self.assertEqual(result["items"], [])
self.assertIn("malformed job", result["error"])
job_id = secrets.token_hex(8)
planted = self.base / "planted.json"
planted.write_text(json.dumps({"v": 1, "id": job_id, "created": "x", "items": [good], "proof": self.proof([good], self.signer)}), encoding="utf-8")
(self.jobs / f"{job_id}.json").symlink_to(planted)
self.assertEqual(host.cycle(self.jobs, self.results, self.writer), 1)
self.assertIn("unreadable job", self.result(job_id)["error"])
pipe = secrets.token_hex(8)
os.mkfifo(self.jobs / f"{pipe}.json")
renamed = secrets.token_hex(8)
self.write_job(renamed, [good], self.proof([good], self.signer))
(self.jobs / f"{renamed}.json").rename(self.jobs / f"{'0' * 16}.json")
self.assertEqual(host.cycle(self.jobs, self.results, self.writer), 2)
self.assertIn("not a regular file", self.result(pipe)["error"])
self.assertEqual((self.result("0" * 16)["items"], self.result("0" * 16)["error"]), ([], "malformed job: refused, nothing changed"))
self.assertEqual((list(self.jobs.iterdir()), self.files()), ([], before))
def test_a_file_json_readers_could_read_differently_fails_and_stays_byte_identical(self):
for name, text, reason in (
("overflowing number", '{"model": 1e400}', "beyond the double range"),
("NaN", '{"model": NaN}', "holds NaN"),
("Infinity", '{"model": Infinity}', "holds Infinity"),
("minus Infinity", '{"model": -Infinity}', "holds -Infinity"),
("repeated key", '{"permissions": {"allow": []}, "permissions": {"deny": []}}', "repeats a key"),
("lone surrogate", '{"model": "\\ud800"}', "lone surrogate"),
("600 levels", '{"model": ' + "[" * 600 + "]" * 600 + "}", "nests deeper than 64"),
("no object", "[]", "no JSON object"),
("no JSON", "{", "no strict JSON"),
):
with self.subTest(name=name):
self.settings.write_text(text + "\n", encoding="utf-8")
before = self.files()
result = self.signed(self.item(self.settings, [ADD_LINT]))
self.assertEqual(result["status"], "failed", result)
self.assertIn(reason, result["reason"])
self.assertNotIn("model", result["reason"])
self.assertEqual(self.files(), before)
shown = self.writer.view()["files"][0]
self.assertEqual((reason in shown["error"], shown["settings"]), (True, {}), shown)
def test_a_poisoned_file_fails_only_its_job_and_the_unit_applies_the_next_and_rewrites_the_view(self):
second = self.base / "second" / ".claude" / "settings.json"
second.parent.mkdir(parents=True)
self.tree.write_text(json.dumps({"repos": [{"path": str(self.project), "known": True, "default": "main"}, {"path": str(second.parent.parent), "known": True, "default": "main"}]}), encoding="utf-8")
self.project_settings.write_text('{"model": "\\ud800"}\n', encoding="utf-8")
second.write_text('{"model": ' + "[" * 600 + "]" * 600 + "}\n", encoding="utf-8")
poisoned = {path: path.read_bytes() for path in (self.project_settings, second)}
jobs = {"0" * 16: self.item(self.project_settings, [ADD_LINT]), "1" * 16: self.item(second, [ADD_LINT]), "f" * 16: self.item(self.settings, [ADD_LINT])}
for job_id, item in jobs.items():
self.write_job(job_id, [item], self.proof([item], self.signer))
view = self.base / "state" / "view.json"
done = self.unit(view, {})
self.assertEqual(done.returncode, 0, done.stderr)
self.assertEqual(list(self.jobs.iterdir()), [])
found = [(self.result(job_id)["items"][0]["status"], self.result(job_id)["items"][0]["reason"]) for job_id in jobs]
self.assertEqual([status for status, _ in found], ["failed", "failed", "done"], found)
self.assertIn("lone surrogate", found[0][1])
self.assertIn("nests deeper than 64", found[1][1])
self.assertEqual({path: path.read_bytes() for path in poisoned}, poisoned)
self.assertEqual([sorted(child.name for child in path.parent.iterdir()) for path in poisoned], [["settings.json"], ["settings.json"]])
self.assertIn("Bash(make lint:*)", json.loads(self.settings.read_text(encoding="utf-8"))["permissions"]["allow"])
shown = {entry["path"]: entry for entry in json.loads(view.read_text(encoding="utf-8"))["files"]}
self.assertEqual(shown[str(self.settings)]["sha256"], sha(self.settings.read_bytes()))
self.assertIn("lone surrogate", shown[str(self.project_settings)]["error"])
self.assertIn("nests deeper than 64", shown[str(second)]["error"])
def test_a_bad_tree_path_or_a_deep_tree_marks_only_itself_and_the_unit_still_applies_and_rewrites_the_view(self):
nul, surrogate = f"{self.base}/nul\x00dir", f"{self.base}/\ud800dir"
for name, text, bad, error in (
("NUL in a path", json.dumps({"repos": [{"path": nul, "known": True}]}), f"{nul}{signing.SETTINGS_FILE}", "unreadable: ValueError"),
("lone surrogate in a path", json.dumps({"repos": [{"path": surrogate, "known": True}]}), f"{surrogate}{signing.SETTINGS_FILE}", "unreadable: UnicodeEncodeError"),
("tree nested 100000 levels", '{"repos": ' + "[" * 100000 + "]" * 100000 + "}", None, None),
):
with self.subTest(name=name):
self.tree.write_text(text, encoding="utf-8")
self.settings.write_text(json.dumps(ORIGINAL, indent=2) + "\n", encoding="utf-8")
item = self.item(self.settings, [ADD_LINT])
job_id = secrets.token_hex(8)
self.write_job(job_id, [item], self.proof([item], self.signer))
view = self.base / "state" / f"{job_id}.json"
done = self.unit(view, {})
self.assertEqual(done.returncode, 0, done.stderr)
self.assertEqual(self.result(job_id)["items"][0]["status"], "done")
shown = {entry["path"]: entry for entry in json.loads(view.read_text(encoding="utf-8"))["files"]}
self.assertEqual(sorted(shown), sorted([str(self.settings), *([bad] if bad else [])]))
self.assertEqual((shown[str(self.settings)]["sha256"], shown[str(self.settings)]["error"]), (sha(self.settings.read_bytes()), ""))
if bad:
self.assertEqual((shown[bad]["error"], shown[bad]["settings"]), (error, {}))
def test_the_view_is_rewritten_even_when_a_result_cannot_be_written(self):
item = self.item(self.settings, [ADD_LINT])
job_id = secrets.token_hex(8)
self.write_job(job_id, [item], self.proof([item], self.signer))
self.results.chmod(0o500)
self.addCleanup(self.results.chmod, 0o700)
view = self.base / "state" / "view.json"
done = self.unit(view, {})
self.assertEqual(done.returncode, 0, done.stderr)
self.assertIn(f"no result for {job_id}.json", done.stderr)
self.assertEqual((list(self.jobs.iterdir()), list(self.results.iterdir())), ([], []))
self.assertEqual(json.loads(view.read_text(encoding="utf-8"))["files"][0]["sha256"], sha(self.settings.read_bytes()))
def test_a_view_that_cannot_be_written_ends_the_unit_with_one_line_and_keeps_the_results(self):
item = self.item(self.settings, [ADD_LINT])
job_id = secrets.token_hex(8)
self.write_job(job_id, [item], self.proof([item], self.signer))
view = self.base / "state" / "view.json"
view.mkdir(mode=0o700, parents=True)
done = self.unit(view, {})
self.assertEqual((done.returncode, "Traceback" in done.stderr), (0, False), done.stderr)
self.assertIn("view not written", done.stderr)
self.assertEqual((self.result(job_id)["items"][0]["status"], view.is_dir()), ("done", True))
def test_a_directory_sync_failing_after_the_replace_reports_the_written_change(self):
real = os.fsync
def failing(fd: int) -> None:
if stat.S_ISDIR(os.fstat(fd).st_mode):
raise OSError(errno.EIO, "Input/output error")
real(fd)
with mock.patch.object(host.os, "fsync", side_effect=failing):
result = self.signed(self.item(self.settings, [ADD_LINT]))
self.assertEqual(result["status"], "done", result)
self.assertIn("written, but its directory sync failed: Input/output error", result["reason"])
self.assertIn("Bash(make lint:*)", json.loads(self.settings.read_text(encoding="utf-8"))["permissions"]["allow"])
self.assertEqual(result["sha256"], sha(self.settings.read_bytes()))
def test_the_unit_makes_no_directory_and_writes_nothing_through_a_linked_spool(self):
victim = self.base / "victim"
victim.mkdir(mode=0o700)
spool = self.base / "spool"
spool.symlink_to(victim)
self.jobs, self.results = spool / "jobs", spool / "results"
done = self.unit(spool / "view.json", {})
self.assertEqual(done.returncode, 0, done.stderr)
self.assertIn("refused, nothing done", done.stderr)
self.assertIn("view not written", done.stderr)
self.assertEqual(list(victim.iterdir()), [])
def test_a_view_in_a_linked_or_foreign_spool_is_refused_and_a_linked_view_file_replaced(self):
victim = self.base / "victim"
victim.mkdir(mode=0o700)
(victim / "view.json").write_text("victim", encoding="utf-8")
linked, shared, real = self.base / "linked", self.base / "shared", self.base / "real"
linked.symlink_to(victim)
shared.mkdir()
shared.chmod(0o770)
real.mkdir(mode=0o700)
(real / "view.json").symlink_to(victim / "view.json")
for folder in (linked, shared, real):
stderr = io.StringIO()
with contextlib.redirect_stderr(stderr):
host.write_view(folder / "view.json", self.writer.view())
with self.subTest(folder=folder.name):
self.assertEqual("view not written" in stderr.getvalue(), folder != real, stderr.getvalue())
self.assertEqual(([path.name for path in victim.iterdir()], (victim / "view.json").read_text(encoding="utf-8"), list(shared.iterdir())), (["view.json"], "victim", []))
self.assertFalse((real / "view.json").is_symlink())
self.assertEqual(json.loads((real / "view.json").read_text(encoding="utf-8"))["files"][0]["path"], str(self.settings))
def test_an_unexpected_crash_fails_only_its_job_or_item_and_names_only_its_kind(self):
apply, problem = signing.apply_changes, signing.settings_problem
crashes = iter([RecursionError("planted depth"), UnicodeEncodeError("utf-8", "planted text", 0, 1, "planted")])
checked = []
def crashing_apply(settings: dict, changes: list[dict]) -> dict:
error = next(crashes, None)
if error is not None:
raise error
return apply(settings, changes)
def crashing_problem(item: object) -> str | None:
checked.append(item)
if len(checked) == 1:
raise KeyError("planted key")
return problem(item)
item = self.item(self.settings, [ADD_LINT])
for job_id in ("0" * 16, "1" * 16, "2" * 16, "f" * 16):
self.write_job(job_id, [item], self.proof([item], self.signer))
with mock.patch.object(host.signing, "apply_changes", crashing_apply), mock.patch.object(host.signing, "settings_problem", crashing_problem):
self.assertEqual(host.cycle(self.jobs, self.results, self.writer), 4)
self.assertEqual((self.result("0" * 16)["items"], self.result("0" * 16)["error"]), ([], "failed: KeyError; nothing changed"))
found = [(self.result(job_id)["items"][0]["status"], self.result(job_id)["items"][0]["reason"]) for job_id in ("1" * 16, "2" * 16, "f" * 16)]
self.assertEqual(found, [("failed", "RecursionError; the file kept its content"), ("failed", "UnicodeEncodeError; the file kept its content"), ("done", "")])
self.assertEqual(json.loads(self.settings.read_text(encoding="utf-8"))["permissions"]["allow"].count("Bash(make lint:*)"), 1)
self.assertEqual(list(self.jobs.iterdir()), [])
def test_a_non_finite_number_never_reaches_the_file_even_past_the_parser(self):
before = self.files()
with mock.patch.object(host, "parsed", return_value={"model": float("inf")}):
result = self.signed(self.item(self.settings, [ADD_LINT]))
self.assertEqual((result["status"], result["reason"]), ("failed", "ValueError; the file kept its content"))
self.assertEqual(self.files(), before)
def test_a_planted_temporary_link_is_never_followed(self):
outside = self.base / "outside.json"
outside.write_text("{}\n", encoding="utf-8")
before = self.settings.read_bytes()
item = self.item(self.settings, [ADD_LINT])
job_id = secrets.token_hex(8)
self.write_job(job_id, [item], self.proof([item], self.signer))
fixed = "0" * 16
(self.settings.parent / f".settings.json.{fixed}").symlink_to(outside)
with mock.patch.object(host.secrets, "token_hex", return_value=fixed):
self.assertEqual(host.cycle(self.jobs, self.results, self.writer), 1)
self.assertEqual(self.result(job_id)["items"][0]["status"], "failed")
self.assertEqual((self.settings.read_bytes(), self.settings.is_symlink(), outside.read_text(encoding="utf-8")), (before, False, "{}\n"))
def test_a_file_of_another_uid_is_refused(self):
before = self.files()
item = self.item(self.settings, [ADD_LINT])
proof = self.proof([item], self.signer)
with mock.patch.object(host.os, "getuid", return_value=os.getuid() + 1):
result = self.run_job([item], proof)["items"][0]
self.assertEqual(result["status"], "refused", result)
self.assertIn(f"belongs to uid {os.getuid()}", result["reason"])
self.assertEqual(self.files(), before)
def test_a_settings_path_that_is_no_regular_file_is_refused(self):
os.mkfifo(self.project_settings)
result = self.signed({"file": str(self.project_settings), "base": sha(b""), "changes": [ADD_LINT]})
self.assertEqual(result["status"], "refused", result)
self.assertIn("no regular file", result["reason"])
self.assertTrue(stat.S_ISFIFO(self.project_settings.lstat().st_mode))
def test_the_view_lists_the_fixed_files_with_only_permissions_and_sandbox(self):
view = self.writer.view()
self.assertEqual([entry["path"] for entry in view["files"]], [str(self.settings), str(self.project_settings)])
own, project = view["files"]
self.assertEqual((own["exists"], own["sha256"], own["error"]), (True, sha(self.settings.read_bytes()), ""))
self.assertEqual(own["settings"], {"permissions": ORIGINAL["permissions"], "sandbox": ORIGINAL["sandbox"]})
self.assertEqual((project["exists"], project["sha256"], project["settings"]), (False, "", {}))
self.assertNotIn("fixture-value-not-a-secret", json.dumps(view))
def test_a_missing_directory_shows_in_the_view_as_the_writer_handles_it(self):
self.project_settings.parent.rmdir()
shown = self.writer.view()["files"][1]
self.assertEqual((shown["exists"], shown["error"]), (False, host.MISSING_DIRECTORY))
result = self.signed({"file": str(self.project_settings), "base": "", "changes": [ADD_LINT]})
self.assertEqual((result["status"], self.project_settings.parent.exists()), ("refused", False), result)
self.project_settings.parent.mkdir()
self.assertEqual(self.writer.view()["files"][1]["error"], "")
self.assertEqual(self.signed({"file": str(self.project_settings), "base": "", "changes": [ADD_LINT]})["status"], "done")
def test_the_unit_runs_once_outside_any_agent_and_refuses_inside_one(self):
item = self.item(self.settings, [ADD_LINT])
before = self.settings.read_bytes()
job_id = secrets.token_hex(8)
self.write_job(job_id, [item], self.proof([item], self.signer))
view = self.base / "state" / "view.json"
for marker in host.AGENT_MARKERS:
with self.subTest(marker=marker):
inside = self.unit(view, {marker: "1"})
self.assertEqual(inside.returncode, 2, inside.stderr)
self.assertIn("refused", inside.stderr)
self.assertEqual((self.settings.read_bytes(), view.exists(), len(list(self.jobs.iterdir()))), (before, False, 1))
done = self.unit(view, {})
self.assertEqual(done.returncode, 0, done.stderr)
self.assertEqual(list(self.jobs.iterdir()), [])
result = self.result(job_id)
self.assertEqual(result["items"][0]["status"], "done", result)
self.assertIn("Bash(make lint:*)", json.loads(self.settings.read_text(encoding="utf-8"))["permissions"]["allow"])
self.assertEqual(((self.results / f"{job_id}.json").stat().st_mode & 0o777, view.stat().st_mode & 0o777), (0o600, 0o600))
self.assertEqual(json.loads(view.read_text(encoding="utf-8"))["files"][0]["sha256"], sha(self.settings.read_bytes()))
class TestSettingsWriterSpoolLinks(spool_links.SpoolLinks, unittest.TestCase):
module = host
def unit(self, trust: verifier.Trust, base: Path):
return host.Writer(trust, base / "home", base / "tree.json")
if __name__ == "__main__":
unittest.main()