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:
commit
d364cfe55f
48 files changed
+3438
-106
No files matched your search
@@ -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
@@ -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"},
|
||||
|
||||
@@ -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 = {
|
||||
|
||||
@@ -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))
|
||||
@@ -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):
|
||||
|
||||
@@ -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: []};
|
||||
|
||||
@@ -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 () => {
|
||||
|
||||
@@ -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 = []
|
||||
|
||||
@@ -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"})
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
Reference in new issue
Block a user