feat(orchestrator)!: S0 English everywhere, Sécurité, NATO hashes, ICAO digits
Requirement 001 phase 6, S0: - Speech: the security class shows as "Sécurité" and is spoken as in maritime radio, "say-cure-ee-tay" three times. A hex run of 7 or more characters with a letter and a digit (commit, session, message ids) is spelled in the NATO alphabet; every other digit is spoken on its own in ICAO pronunciation (42305: four two tree zero fife). The spelling runs inside clip() before the length cut, so a phrase still fits SPEECH_LIMIT; the displayed text keeps its digits and hashes. - English: every orchestrator label, tooltip, message, error, script output, document and test string is English (Regeln -> Firewall, Hierarchie -> Hierarchy, Steuerung -> Controls, Ausführen -> Run, ...); the page declares lang="en" and formats dates as en-GB. Task filter ids are English. German stays only in the skill trigger phrases that quote the operator, and as identifiers: the view keys (view=) and the leitstand id. - tests/test_english.py scans every tracked text file for umlauts and German words, with an allowlist of the quoted trigger phrases. BREAKING CHANGE: the Stream search tokens art: and seit: are now kind: and since:; an old art: or seit: token counts as a plain word. Evidence: make test 657 OK, ruff and markdownlint clean (/tmp/s0-make-test-1.log); e2e 17 OK, none skipped (/tmp/s0-e2e-1.log); MEDUSA 86 files, 24 findings on reworded strings accepted after an independent skeptic (21 path:line, 0 rejected, no behaviour change in signing, approving, rules, denying, offices, events), rescan 0 open. 🎯 Fix: 93 % 💥 Break: 4 % 💸 Cost: 100 % ⏱️ Time: – 🛡️ Security: 100 % 🏆 Score: 89 🚦 Gate: ✅ 90/5, cost and time <= 100, security 100 % Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
a388c6ef77
commit
c035373518
86 files changed
+1027
-930
No files matched your search
@@ -81,7 +81,7 @@ class Approving:
|
||||
try:
|
||||
verifier.check(proof, item, "", trust, time.time())
|
||||
except signing.Refused as error:
|
||||
raise ToolError(f"nicht signiert: {error}") from None
|
||||
raise ToolError(f"not signed: {error}") from None
|
||||
return proof
|
||||
|
||||
def still_signed(self, proof: dict, item: dict) -> None:
|
||||
@@ -94,7 +94,7 @@ class Approving:
|
||||
raise signing.Refused("the signature does not list this item")
|
||||
passkey.verify_assertion(proof["assertion"], proof["payload"], verifier.pinned(self.approvers), signing.origin_of(self.public_port))
|
||||
except signing.Refused as error:
|
||||
raise ToolError(f"nicht signiert: {error}") from None
|
||||
raise ToolError(f"not signed: {error}") from None
|
||||
|
||||
def covered(self, proof: object, signed: list[dict], now: float) -> dict | None:
|
||||
"""Args:
|
||||
@@ -112,7 +112,7 @@ class Approving:
|
||||
raise ToolError("proof must be null when no item needs a signature")
|
||||
return None
|
||||
if not isinstance(proof, dict):
|
||||
raise ToolError("nicht signiert: an approval of an ask, review or operator command needs the passkey signature")
|
||||
raise ToolError("not signed: an approval of an ask, review or operator command needs the passkey signature")
|
||||
expect(proof, ("payload", "assertion"))
|
||||
try:
|
||||
payload = signing.checked_approval(proof["payload"], now)
|
||||
@@ -136,15 +136,15 @@ class Approving:
|
||||
item = {"kind": kind_name, "id": record["id"], "verb": "approve", "label": record.get("recommended", ""), "sha256": "", "title": shown(title)[:200], "gate": record.get("gate", ""), "signed": signed, "note": None}
|
||||
batch = self.batches.add([item], f"rule:{rule['id']}", rule.get("proof"), self.apply)
|
||||
words = f"{rule['kind']} {rule['tool']} {rule['pattern']}".replace(" ", " ")
|
||||
self.log.add({"kind": "rule", "title": f"Regel gibt frei: {item['title']}", "text": words, "ref": {"rule": rule["id"], "batch": batch["id"], "item": item["id"]}})
|
||||
self.log.add({"kind": "rule", "title": f"Rule grants: {item['title']}", "text": words, "ref": {"rule": rule["id"], "batch": batch["id"], "item": item["id"]}})
|
||||
|
||||
def apply(self, batch: dict) -> None:
|
||||
for item in batch["items"]:
|
||||
try:
|
||||
outcome = self.settle_item(item, batch["proof"] if item["signed"] is not None else None)
|
||||
except (OSError, ToolError) as error:
|
||||
outcome = f"fehlgeschlagen: {error}"
|
||||
verb = "Freigabe" if item["verb"] == "approve" else "Ablehnung"
|
||||
outcome = f"failed: {error}"
|
||||
verb = "Grant" if item["verb"] == "approve" else "Denial"
|
||||
label = f" → {item['label']}" if item["label"] else ""
|
||||
ref = {"kind": item["kind"], "id": item["id"], "verb": item["verb"], "source": batch["source"], "outcome": outcome}
|
||||
self.log.add({"kind": "approval", "title": f"{verb} {item['kind']}: {item['title']}{label}", "text": f"{outcome} ({batch['source']})", "ref": ref})
|
||||
@@ -158,15 +158,15 @@ class Approving:
|
||||
if item["kind"] == "ask":
|
||||
record = self.asks.get(item["id"])
|
||||
if record is None or ask_state(record, time.time())["status"] == "expired":
|
||||
return "abgelaufen"
|
||||
return "expired"
|
||||
record, changed = self.asks.decide(item["id"], {"status": "allowed" if approve else "denied", "proof": proof})
|
||||
elif item["kind"] == "review":
|
||||
record, changed = self.reviews.decide(item["id"], {"status": "approved" if approve else "rejected", "proof": proof})
|
||||
else:
|
||||
record, changed = self.decisions.decide(item["id"], {"status": "decided", "choice": item["label"]})
|
||||
if record is None:
|
||||
return "unbekannt"
|
||||
return record["status"] if changed else f"schon {record['status']}"
|
||||
return "unknown"
|
||||
return record["status"] if changed else f"already {record['status']}"
|
||||
|
||||
def requester(self, raw: dict, who: str) -> str:
|
||||
"""Returns:
|
||||
@@ -216,7 +216,7 @@ class Approving:
|
||||
raise ToolError("a decision is approved with one of its option labels")
|
||||
label = raw["label"]
|
||||
if kind_name == "rule":
|
||||
return inbox_item(raw, "", f"Regel {request_words(record)}", "", request_signed(record), self.requester(raw, record["agent"]))
|
||||
return inbox_item(raw, "", f"Rule {request_words(record)}", "", request_signed(record), self.requester(raw, record["agent"]))
|
||||
title = {"review": record.get("title"), "ask": f"{record.get('tool')} {record.get('command')}", "decision": record.get("question")}[kind_name]
|
||||
subject = {"review": review_signed, "ask": ask_signed}[kind_name](record) if kind_name != "decision" else None
|
||||
return inbox_item(raw, label, title, record.get("gate", ""), subject, self.requester(raw, record["session"] if kind_name == "ask" else ""))
|
||||
@@ -259,5 +259,5 @@ class Approving:
|
||||
def undo(self, batch_id: str) -> dict:
|
||||
batch = self.batches.undo(batch_id)
|
||||
titles = ", ".join(item["title"][:80] for item in batch["items"])
|
||||
self.log.add({"kind": "approval", "title": f"Rückgängig: {titles}", "text": batch["source"], "ref": {"batch": batch_id}})
|
||||
self.log.add({"kind": "approval", "title": f"Undone: {titles}", "text": batch["source"], "ref": {"batch": batch_id}})
|
||||
return {"id": batch_id, "status": "undone"}
|
||||
@@ -71,7 +71,7 @@ class Cleaning:
|
||||
raise ToolError(f"items must be a list of 1 to {ITEM_LIMIT} objects")
|
||||
scan = self.tree.get()
|
||||
if scan.get("delete_ready") is not True:
|
||||
raise ToolError(f"löschen gesperrt: {scan.get('delete_reason') or scan.get('error') or 'delete_ready ist false'}")
|
||||
raise ToolError(f"delete blocked: {scan.get('delete_reason') or scan.get('error') or 'delete_ready is false'}")
|
||||
known = offered(scan)
|
||||
chosen = []
|
||||
for entry in raw:
|
||||
@@ -94,7 +94,7 @@ class Cleaning:
|
||||
job = {"v": JOB_VERSION, "id": job_id, "created": stamp(), "items": [{key: item[key] for key in JOB_KEYS} for item in items], "proof": proof}
|
||||
self.spool.put(job_id, job)
|
||||
names = ", ".join(item["branch"] for item in items)
|
||||
self.log.add({"kind": "run", "title": f"Löschen signiert: {names}"[:200], "text": "\n".join(f"{item['repository']} {item['branch']} @ {item['tip'][:12]}" for item in items), "ref": {"cleanup": job_id, "status": "queued"}})
|
||||
self.log.add({"kind": "run", "title": f"Delete signed: {names}"[:200], "text": "\n".join(f"{item['repository']} {item['branch']} @ {item['tip'][:12]}" for item in items), "ref": {"cleanup": job_id, "status": "queued"}})
|
||||
return {"id": job_id, "status": "queued", "items": job["items"]}
|
||||
|
||||
def cleanup_state(self, job_id: str) -> dict:
|
||||
|
||||
@@ -9,7 +9,7 @@ from .records import epoch, read_json, shown
|
||||
|
||||
CRON_ACTIVE = 900
|
||||
TIMER_KEYS = ("OnCalendar", "OnActiveSec", "OnBootSec", "OnStartupSec", "OnUnitActiveSec", "OnUnitInactiveSec")
|
||||
CRON_LABELS = {"cron": "Cron", "wakeup": "Wakeup", "background": "Hintergrund", "timer": "Timer", "queue": "Queue"}
|
||||
CRON_LABELS = {"cron": "Cron", "wakeup": "Wakeup", "background": "Background", "timer": "Timer", "queue": "Queue"}
|
||||
|
||||
|
||||
def cron_state(cron: dict, beats: dict[str, float], now: float) -> dict:
|
||||
@@ -59,7 +59,7 @@ def queue_entries(council: Path) -> list[tuple[dict, float]]:
|
||||
def queue_rows(council: Path) -> list[dict]:
|
||||
rows = []
|
||||
for entry, created in queue_entries(council):
|
||||
running = "läuft" if entry.get("status") == "active" else "wartet"
|
||||
running = "running" if entry.get("status") == "active" else "waiting"
|
||||
rows.append({
|
||||
"key": f"queue:{shown(entry.get('id'))}", "type": "queue", "session": shown(entry.get("session")), "sub": "", "created": created,
|
||||
"deleted": None, "until": None, "job": shown(entry.get("id")), "expression": f"{shown(entry.get('kind'))} · {running}",
|
||||
|
||||
@@ -76,28 +76,28 @@ class Denying:
|
||||
tasks = read_register(self.council / REGISTER)
|
||||
row = next((row for row in operator_rows(tasks) if row["task"] == item["id"]), None)
|
||||
if row is None or signing.denial_item(operator_signed(row), note["channel"], note["reason"], note["to"]) != item["signed"]:
|
||||
return "verweigert: die Zeile hat sich seit der Ablehnung geändert"
|
||||
return "refused: the row changed since the denial"
|
||||
if item["id"] in self.open_jobs():
|
||||
return "läuft schon"
|
||||
return "already running"
|
||||
run = self.scripts.run(RASCI, ["set", item["id"], "--status", "stopped"])
|
||||
if run["code"] != 0:
|
||||
return f"fehlgeschlagen: {run['command']} → {run['code']}"
|
||||
return f"failed: {run['command']} → {run['code']}"
|
||||
command, directory = row["command"][:200], row["directory"]
|
||||
return f"gestoppt · {self.tell(item, proof, adder(tasks[item['id']]), f'operator command {command} in {directory}')}"
|
||||
return f"stopped · {self.tell(item, proof, adder(tasks[item['id']]), f'operator command {command} in {directory}')}"
|
||||
ledger = self.asks if item["kind"] == "ask" else self.rule_requests
|
||||
record = ledger.get(item["id"])
|
||||
if record is None:
|
||||
return "unbekannt"
|
||||
return "unknown"
|
||||
now = time.time()
|
||||
if (ask_state(record, now)["status"] if item["kind"] == "ask" else request_status(record, now)) == "expired":
|
||||
return "abgelaufen"
|
||||
return "expired"
|
||||
record, changed = ledger.decide(item["id"], {"status": "denied", "proof": proof, **note})
|
||||
if not changed:
|
||||
return f"schon {record['status']}"
|
||||
return f"already {record['status']}"
|
||||
if item["kind"] == "ask":
|
||||
tool, command = record["tool"], record["command"][:200]
|
||||
return f"abgelehnt · {self.tell(item, proof, record['session'], f'ask {tool}: {command}')}"
|
||||
return f"abgelehnt · {self.tell(item, proof, record['agent'], f'rule request {request_words(record)}')}"
|
||||
return f"denied · {self.tell(item, proof, record['session'], f'ask {tool}: {command}')}"
|
||||
return f"denied · {self.tell(item, proof, record['agent'], f'rule request {request_words(record)}')}"
|
||||
|
||||
def addressee(self, who: str) -> tuple[str, str]:
|
||||
return requester_of(read_claims(self.council), who)
|
||||
@@ -120,11 +120,11 @@ class Denying:
|
||||
direct = channel in DIRECT
|
||||
address = self.addressee(note["to"])[1] if direct else EVERYONE
|
||||
if direct and not address:
|
||||
return f"kein Empfänger für {channel}"
|
||||
return f"no recipient for {channel}"
|
||||
text = denial_text(what, self.addressee(who)[0], note["reason"])
|
||||
where = f"{channel} an {address}" if direct else f"{channel} an alle"
|
||||
where = f"{channel} to {address}" if direct else f"{channel} to all"
|
||||
fields = {"to": note["to"], "address": address, "text": text, "upload": None, "voice": None, "voice_sha256": "", "class": channel}
|
||||
record = self.messages.add({**fields, "denial": item["signed"], "proof": proof, "created_ts": time.time()})
|
||||
targets = ["--to", address] if direct else []
|
||||
run = self.scripts.run(RADIO, [*DENY_CHANNELS[channel], *targets, "--session", HUMAN, f"[kvb-orchestrator msg {record['id']}] {' '.join(text.split())}"])
|
||||
return where if run["code"] == 0 else f"{where} fehlgeschlagen ({run['code']})"
|
||||
return where if run["code"] == 0 else f"{where} failed ({run['code']})"
|
||||
@@ -17,18 +17,18 @@ from .register import status_of
|
||||
from .transcripts import LOG_KEEP, STREAM_CUT, STREAM_KINDS
|
||||
|
||||
KINDS = (
|
||||
("radio", "Funk"), ("review", "Reviews"), ("ask", "Asks"), ("decision", "Entscheidungen"), ("operator", "Operator"), ("register", "Register"),
|
||||
("rename", "Namen"), ("cron", "Crons"), ("rule", "Regeln"), ("approval", "Freigaben"), ("run", "Runner"), ("transcript", "Transkripte"),
|
||||
("radio", "Radio"), ("review", "Reviews"), ("ask", "Asks"), ("decision", "Decisions"), ("operator", "Operator"), ("register", "Register"),
|
||||
("rename", "Names"), ("cron", "Crons"), ("rule", "Firewall"), ("approval", "Grants"), ("run", "Runner"), ("transcript", "Transcripts"),
|
||||
)
|
||||
EVENT_KINDS = tuple(name for name, _ in KINDS)
|
||||
WORK = [name for name in EVENT_KINDS if name not in ("radio", "transcript")]
|
||||
VIEWS = {
|
||||
"fuer-dich": {"label": "Für dich", "kinds": ["radio", *WORK], "waiting": True},
|
||||
"funk": {"label": "Funk", "kinds": ["radio"], "waiting": False},
|
||||
"arbeit": {"label": "Arbeit", "kinds": WORK, "waiting": False},
|
||||
"transkripte": {"label": "Transkripte", "kinds": ["transcript"], "waiting": False},
|
||||
"fuer-dich": {"label": "For you", "kinds": ["radio", *WORK], "waiting": True},
|
||||
"funk": {"label": "Radio", "kinds": ["radio"], "waiting": False},
|
||||
"arbeit": {"label": "Work", "kinds": WORK, "waiting": False},
|
||||
"transkripte": {"label": "Transcripts", "kinds": ["transcript"], "waiting": False},
|
||||
}
|
||||
ART = {word: name for name, label in KINDS for word in (name, label.lower())}
|
||||
KIND_WORDS = {word: name for name, label in KINDS for word in (name, label.lower())}
|
||||
SPAN = re.compile(r"(\d{1,4})([mhd])")
|
||||
UNITS = {"m": 60, "h": 3600, "d": 86400}
|
||||
|
||||
@@ -44,14 +44,14 @@ def since_of(word: str, now: float) -> float:
|
||||
try:
|
||||
return datetime.datetime.fromisoformat(word).timestamp()
|
||||
except ValueError:
|
||||
raise ToolError("seit: takes 30m, 2h, 3d or a date like 2026-11-06 or 2026-11-06T08:30") from None
|
||||
raise ToolError("since: takes 30m, 2h, 3d or a date like 2026-11-06 or 2026-11-06T08:30") from None
|
||||
|
||||
|
||||
def search(text: str, now: float) -> dict:
|
||||
"""Args:
|
||||
text: the search line: words, `agent:<name>`, `art:<kind or label>`
|
||||
and `seit:<span or date>`.
|
||||
now: the clock `seit:` spans count back from.
|
||||
text: the search line: words, `agent:<name>`, `kind:<kind or label>`
|
||||
and `since:<span or date>`.
|
||||
now: the clock `since:` spans count back from.
|
||||
|
||||
Returns:
|
||||
The plain words as `q`, plus `agent`, `kinds` and `since` for each
|
||||
@@ -60,16 +60,16 @@ def search(text: str, now: float) -> dict:
|
||||
found: dict = {"q": []}
|
||||
for word in text.split():
|
||||
key, colon, value = word.partition(":")
|
||||
if not colon or key not in ("agent", "art", "seit"):
|
||||
if not colon or key not in ("agent", "kind", "since"):
|
||||
found["q"].append(word)
|
||||
elif not value:
|
||||
raise ToolError(f"{key}: needs a value")
|
||||
elif key == "agent":
|
||||
found["agent"] = value
|
||||
elif key == "art":
|
||||
if value.lower() not in ART:
|
||||
raise ToolError(f"art: takes one of {', '.join(EVENT_KINDS)}")
|
||||
found.setdefault("kinds", set()).add(ART[value.lower()])
|
||||
elif key == "kind":
|
||||
if value.lower() not in KIND_WORDS:
|
||||
raise ToolError(f"kind: takes one of {', '.join(EVENT_KINDS)}")
|
||||
found.setdefault("kinds", set()).add(KIND_WORDS[value.lower()])
|
||||
else:
|
||||
found["since"] = since_of(value, now)
|
||||
found["q"] = " ".join(found["q"]).lower()
|
||||
@@ -128,7 +128,7 @@ def register_changes(before: dict[str, dict], after: dict[str, dict], now: float
|
||||
continue
|
||||
if old is None or new is None:
|
||||
row = new if old is None else old
|
||||
change = f"neu: {shown(row.get('title'))}" if old is None else "entfernt"
|
||||
change = f"new: {shown(row.get('title'))}" if old is None else "removed"
|
||||
else:
|
||||
keys = sorted(key for key in set(old) | set(new) if old.get(key) != new.get(key))
|
||||
change = "; ".join(f"{key}: {described(old.get(key))} → {described(new.get(key))}" for key in keys)
|
||||
|
||||
@@ -54,12 +54,12 @@ class Jobs:
|
||||
def queue_job(self, item: dict, proof: dict | None) -> str:
|
||||
row = next((row for row in operator_rows(read_register(self.council / REGISTER)) if row["task"] == item["id"]), None)
|
||||
if row is None or not runnable(row) or operator_signed(row) != item["signed"]:
|
||||
return "verweigert: die Zeile hat sich seit der Freigabe geändert"
|
||||
return "refused: the row changed since the grant"
|
||||
if item["id"] in self.open_jobs():
|
||||
return "läuft schon"
|
||||
return "already running"
|
||||
job = {"task": row["task"], "command": row["command"], "directory": row["directory"], "sha256": item["sha256"], "status": "queued", "proof": proof}
|
||||
self.jobs.add({**job, "code": None, "output": "", "created_ts": time.time(), "started": None, "finished": None, "dismissed": False})
|
||||
return "an den Runner übergeben"
|
||||
return "handed to the runner"
|
||||
|
||||
def runner_jobs(self) -> dict:
|
||||
return {"jobs": [runner_job(job) for job in self.jobs.listed() if job["status"] == "queued"]}
|
||||
|
||||
@@ -87,36 +87,36 @@ def nl_action(raw: object, items: dict[str, dict], agents: list[str]) -> dict:
|
||||
raise ToolError("that operator row holds no command to run")
|
||||
chosen = [nl_item(item, "approve" if name == "approve" else "reject", item["recommended"] if item["kind"] == "decision" else "") for item in picked]
|
||||
lines = [f"{item['kind']} {item['id']}: {item['command'] if item['kind'] == 'operator' else item['title']}" for item in picked]
|
||||
verb = "Freigeben" if name == "approve" else "Ablehnen"
|
||||
verb = "Grant" if name == "approve" else "Deny"
|
||||
return {"name": name, "summary": f"{verb}:\n" + "\n".join(lines), "args": {"items": chosen}}
|
||||
if name == "choose":
|
||||
item = items.get(arguments["id"]) if isinstance(arguments["id"], str) else None
|
||||
if item is None or item["kind"] != "decision" or arguments["label"] not in [option["label"] for option in item["options"]]:
|
||||
raise ToolError("choose takes a decision id and one of its option labels")
|
||||
return {"name": name, "summary": f"Entscheiden: {item['title']} → {arguments['label']}", "args": {"items": [nl_item(item, "approve", arguments["label"])]}}
|
||||
return {"name": name, "summary": f"Decide: {item['title']} → {arguments['label']}", "args": {"items": [nl_item(item, "approve", arguments["label"])]}}
|
||||
if name in ("snooze", "pin"):
|
||||
picked = nl_ids(arguments, items)
|
||||
hours = arguments.get("hours")
|
||||
if name == "snooze" and (isinstance(hours, bool) or not isinstance(hours, int | float) or not 1 <= hours <= 192):
|
||||
raise ToolError("hours must be between 1 and 192")
|
||||
keys = [{"kind": item["kind"], "id": item["id"]} for item in picked]
|
||||
words = f"Zurückstellen ({hours} h)" if name == "snooze" else "Anheften"
|
||||
words = f"Snooze ({hours} h)" if name == "snooze" else "Pin"
|
||||
return {"name": name, "summary": f"{words}: " + ", ".join(item["title"][:80] for item in picked), "args": {"keys": keys, "hours": hours}}
|
||||
if name == "view":
|
||||
if arguments["name"] not in VIEWS:
|
||||
raise ToolError("unknown view")
|
||||
return {"name": name, "summary": f"Ansicht: {VIEWS[arguments['name']]['label']}", "args": {"name": arguments["name"]}}
|
||||
return {"name": name, "summary": f"View: {VIEWS[arguments['name']]['label']}", "args": {"name": arguments["name"]}}
|
||||
if name == "open":
|
||||
if arguments["view"] not in SCREENS:
|
||||
raise ToolError("unknown screen")
|
||||
return {"name": name, "summary": f"Öffnen: {arguments['view']}", "args": {"view": arguments["view"]}}
|
||||
return {"name": name, "summary": f"Open: {arguments['view']}", "args": {"view": arguments["view"]}}
|
||||
if name == "message":
|
||||
text = message_text(arguments, "text")
|
||||
if arguments["to"] not in agents:
|
||||
raise ToolError("to must name a known agent")
|
||||
return {"name": name, "summary": f"Funk an {arguments['to']}: {text}", "args": {"to": arguments["to"], "text": text}}
|
||||
return {"name": name, "summary": f"Radio to {arguments['to']}: {text}", "args": {"to": arguments["to"], "text": text}}
|
||||
query = bounded(arguments, "q", 200)
|
||||
return {"name": name, "summary": f"Suchen: {query}", "args": {"q": query}}
|
||||
return {"name": name, "summary": f"Search: {query}", "args": {"q": query}}
|
||||
|
||||
|
||||
def nl_actions(reply: str, items: list[dict], agents: list[str]) -> dict:
|
||||
|
||||
@@ -75,8 +75,8 @@ class Directory:
|
||||
if begin <= after["first_seen"] <= end:
|
||||
found.append(event({
|
||||
"id": f"rename:{session}:{after['first_seen']}", "ts": after["first_seen"], "kind": "rename", "agent": after["name"],
|
||||
"now": self.now(session), "session": session, "title": f"{before['name']} heißt jetzt {after['name']}",
|
||||
"text": f"Quelle: {after['source']}", "ref": {"before": before["name"], "after": after["name"], "source": after["source"]},
|
||||
"now": self.now(session), "session": session, "title": f"{before['name']} is now called {after['name']}",
|
||||
"text": f"Source: {after['source']}", "ref": {"before": before["name"], "after": after["name"], "source": after["source"]},
|
||||
}))
|
||||
return found
|
||||
|
||||
|
||||
@@ -11,7 +11,7 @@ from .signed import signing
|
||||
|
||||
ITEM_LIMIT = 20
|
||||
JOB_VERSION = 1
|
||||
LABELS = {"appoint": "besetzt", "takeover": "übergeben", "recall": "abberufen"}
|
||||
LABELS = {"appoint": "appointed", "takeover": "handed over", "recall": "recalled"}
|
||||
|
||||
|
||||
def office_request(raw: object) -> bool:
|
||||
@@ -77,7 +77,7 @@ class Offices:
|
||||
self.office_spool.put(job_id, job)
|
||||
names = ", ".join(f"{item['office']} {LABELS[item['action']]}" for item in items)
|
||||
lines = "\n".join(f"{item['action']} {item['office']}: {item['holder'] or '-'} -> {item['session'] or '-'}" for item in items)
|
||||
self.log.add({"kind": "run", "title": f"Amt signiert: {names}"[:200], "text": lines, "ref": {"offices": job_id, "status": "queued"}})
|
||||
self.log.add({"kind": "run", "title": f"Office signed: {names}"[:200], "text": lines, "ref": {"offices": job_id, "status": "queued"}})
|
||||
return {"id": job_id, "status": "queued", "items": job["items"]}
|
||||
|
||||
def office_state(self, job_id: str) -> dict:
|
||||
|
||||
@@ -8,16 +8,38 @@ SPEECH_LIMIT = 1000
|
||||
SPOKEN_TEXT = 500
|
||||
SPOKEN_NAME = 60
|
||||
SPOKEN_GROUP = 120
|
||||
ALARM_WORDS = {"pan-pan": "PAN-PAN", "security": "SECURITE"}
|
||||
ALARM_WORDS = {"pan-pan": "PAN-PAN", "security": "say-cure-ee-tay"}
|
||||
ADDRESSED = ("post", "call", "receipt")
|
||||
CALLS = re.compile(r"^(?:(?:MAYDAY|PAN[ -]?PAN|SECURIT[EÉY])\b[\s:,.;!-]*)+", re.IGNORECASE)
|
||||
HUB_MARK = re.compile(r"\[kvb-orchestrator msg [0-9a-f]{16}\]")
|
||||
HUB_FILE = re.compile(r"\s+file: /\S*$")
|
||||
SPOKEN_LINE = re.compile(LINE.format(SPEECH_LIMIT))
|
||||
HASH = re.compile(r"\b(?=[0-9a-f]*[a-f])(?=[0-9a-f]*[0-9])[0-9a-f]{7,}\b|[0-9]", re.IGNORECASE)
|
||||
NATO = dict(zip("abcdef", ("alfa", "bravo", "charlie", "delta", "echo", "foxtrot")))
|
||||
ICAO = dict(zip("0123456789", ("zero", "one", "two", "tree", "four", "fife", "six", "seven", "eight", "niner")))
|
||||
|
||||
|
||||
def pronounced(text: str) -> str:
|
||||
"""Args:
|
||||
text: a radio text as displayed.
|
||||
|
||||
Returns:
|
||||
The text with each hex run of 7 or more characters holding a letter
|
||||
and a digit spelled in the NATO alphabet and every other digit
|
||||
spoken on its own in ICAO pronunciation.
|
||||
"""
|
||||
return HASH.sub(spelled, text)
|
||||
|
||||
|
||||
def spelled(found: re.Match) -> str:
|
||||
start, end = found.span()
|
||||
before = " " if start and found.string[start - 1].isalnum() else ""
|
||||
after = " " if end < len(found.string) and found.string[end].isalnum() else ""
|
||||
return before + " ".join(NATO.get(char) or ICAO[char] for char in found[0].lower()) + after
|
||||
|
||||
|
||||
def clip(text: str, limit: int) -> str:
|
||||
words = " ".join(text.split())
|
||||
words = " ".join(pronounced(text).split())
|
||||
if len(words) <= limit:
|
||||
return words
|
||||
return words[:limit].rsplit(" ", 1)[0] or words[:limit]
|
||||
|
||||
@@ -49,7 +49,7 @@ class Requesting:
|
||||
raise ToolError(f"{name} already has {AGENT_CAP} pending rule requests; wait for their answer with rule_request_wait")
|
||||
|
||||
record = self.rule_requests.add_checked({**fields, "agent": name, "why": why, "status": "pending", "rule": None, "reason": "", "channel": "", "proof": None, "decided": None, "created_ts": now}, capped)
|
||||
self.log.add({"kind": "rule", "title": f"Regelwunsch von {name}: {request_words(record)}", "text": why, "ref": {"request": record["id"]}})
|
||||
self.log.add({"kind": "rule", "title": f"Rule request from {name}: {request_words(record)}", "text": why, "ref": {"request": record["id"]}})
|
||||
return {"id": record["id"], "status": record["status"], "url": self.url()}
|
||||
|
||||
def rule_request_wait(self, arguments: dict) -> dict:
|
||||
@@ -78,7 +78,7 @@ class Requesting:
|
||||
items = []
|
||||
for record in self.open_requests(now):
|
||||
rule = {key: record[key] for key in RULE_FIELDS}
|
||||
fields = {"title": f"Regel: {request_words(record)}", "agent": record["agent"], "to": requester_of(claims, record["agent"])[0], "detail": record["why"], "rule": rule, "dry_run": self.dry_run(record, now), "deniable": True}
|
||||
fields = {"title": f"Rule: {request_words(record)}", "agent": record["agent"], "to": requester_of(claims, record["agent"])[0], "detail": record["why"], "rule": rule, "dry_run": self.dry_run(record, now), "deniable": True}
|
||||
items.append({**base, "kind": "rule", "id": record["id"], "ts": record["created_ts"], **fields})
|
||||
return items
|
||||
|
||||
@@ -113,5 +113,5 @@ class Requesting:
|
||||
if not changed:
|
||||
raise Conflict(request_state(decided, now))
|
||||
self.store_rule(rule, fields, proof, True, now)
|
||||
self.log.add({"kind": "rule", "title": f"Regelwunsch angenommen: {request_words(record)}", "text": f"von {record['agent']}", "ref": {"request": request_id, "rule": rule["id"]}})
|
||||
self.log.add({"kind": "rule", "title": f"Rule request accepted: {request_words(record)}", "text": f"from {record['agent']}", "ref": {"request": request_id, "rule": rule["id"]}})
|
||||
return request_state(decided, now)
|
||||
@@ -72,7 +72,7 @@ class Rules:
|
||||
try:
|
||||
passkey.verify_assertion(assertion, rule, verifier.pinned(self.approvers), signing.origin_of(self.public_port))
|
||||
except signing.Refused as error:
|
||||
raise ToolError(f"nicht signiert: {error}") from None
|
||||
raise ToolError(f"not signed: {error}") from None
|
||||
return {"payload": rule, "assertion": assertion}
|
||||
|
||||
def store_rule(self, rule: dict, fields: dict, proof: dict, enabled: bool, now: float) -> dict:
|
||||
|
||||
@@ -66,5 +66,5 @@ class Tasking:
|
||||
fields = {"kind": TASK_JOB, "task": item["id"], "argv": item["argv"], "command": shown_command(item["argv"]), "directory": "", "sha256": "", "status": "queued", "proof": proof}
|
||||
ids.append(self.jobs.add({**fields, "code": None, "output": "", "created_ts": time.time(), "started": None, "finished": None})["id"])
|
||||
commands = [shown_command(item["argv"]) for item in items]
|
||||
self.log.add({"kind": "run", "title": f"Aufgabe signiert geändert: {', '.join(item['id'] for item in items)}"[:200], "text": "\n".join(commands), "ref": {"jobs": ids, "status": "queued"}})
|
||||
self.log.add({"kind": "run", "title": f"Task change signed: {', '.join(item['id'] for item in items)}"[:200], "text": "\n".join(commands), "ref": {"jobs": ids, "status": "queued"}})
|
||||
return {"jobs": ids, "status": "queued"}
|
||||
@@ -53,7 +53,7 @@ class Timeline:
|
||||
rows = []
|
||||
for index, row in enumerate(radio_rows(radio, begin, end)):
|
||||
alarm = row["class"] in ("mayday", "pan-pan") and row["ts"] >= end - MAYDAY_ACTIVE
|
||||
title = f"{row['from'] or '?'} → {', '.join(row['to']) or 'alle'}"
|
||||
title = f"{row['from'] or '?'} → {', '.join(row['to']) or 'all'}"
|
||||
source = directory.key(row["from"], row["ts"])
|
||||
who = {"agent": directory.at(source, row["ts"]) or row["from"], "now": directory.now(source), "session": source}
|
||||
ref = {"to": row["to"], "class": row["class"], "targets": [directory.key(name, row["ts"]) for name in row["to"]]}
|
||||
|
||||
@@ -73,19 +73,19 @@ def dry_run(item: dict) -> list[str]:
|
||||
always stays.
|
||||
"""
|
||||
tip = (item["local_sha"] or item["head"] or "")[:12]
|
||||
merged = f", gemergt durch {item['merged_by']}" if item["merged_by"] else ""
|
||||
merged = f", merged by {item['merged_by']}" if item["merged_by"] else ""
|
||||
lines = [f"{item['branch']} @ {tip}: {item['state']}{merged}"]
|
||||
for action in item["actions"]:
|
||||
if action == "worktree":
|
||||
lines.append(f"entfernt den Worktree {item['worktree']}")
|
||||
lines.append(f"removes the worktree {item['worktree']}")
|
||||
elif action == "local-branch":
|
||||
lines.append(f"löscht den lokalen Branch {item['branch']}")
|
||||
lines.append(f"deletes the local branch {item['branch']}")
|
||||
elif action.startswith("remote"):
|
||||
lines.append(f"bleibt: {action} (nur lokal)")
|
||||
lines.append(f"stays: {action} (local only)")
|
||||
else:
|
||||
lines.append(action)
|
||||
lines += [f"stoppt den Compose-Stack {name} ohne -v" for name in item["compose_projects"]]
|
||||
lines += [f"entfernt das Image {name}" for name in item["images"]]
|
||||
lines += [f"stops the Compose stack {name} without -v" for name in item["compose_projects"]]
|
||||
lines += [f"removes the image {name}" for name in item["images"]]
|
||||
return lines
|
||||
|
||||
|
||||
|
||||
Reference in new issue
Block a user