Files
skills/orchestrator/kvb_orchestrator/exchange.py
T
Kevin Veen-BirkenbachandClaude Opus 5.5 acf39255fc feat(orchestrator): radio set with CPU-gated speech, noise burst, modes and log (requirement 004)
The hub gates uncached /api/tts renders on the latest W4 host CPU sample (503 busy or unknown, cached lines always served, signed speech.threshold 30 to 90 in steps of 10, speech.gate in /api/state). The page plays a WebAudio squelch-tail burst when no speech plays, offers Auto, Quiet and Silence per browser, and always sounds the MAYDAY, PAN-PAN and SECURITE procedure word. The radio panel becomes a minimalist VHF faceplate with display line, mode buttons, knobs, PTT send and the internet station; the settings dialog loses its radio section. The log gets Sent, Received and All tabs with class, sender, recipient and agent chips plus text search. Decisions 3 and 10 of 004 now state that the procedure word still sounds in Silence.

Security: MEDUSA-MEX-SCAN-1167 at orchestrator/kvb_orchestrator/hub.py:126 accepted as a false positive after the round 5 skeptic review and the operator pick of 2026-11-13 (regex hit on rce inside RESOURCES; CpuGate reads host CPU samples, no model).

Break risk 6 % is above the 5 % bar; committed and merged on the operator pick of 2026-11-13 for this bundle.

🎯 Fix: 92 %
💥 Break: 6 %
💸 Cost: 100 %
⏱️ Time: 100 %
🛡️ Security: 100 %
🏆 Score: 86
🚦 Gate: ⛔ break 6 % > 5

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-13 10:48:13 +00:00

111 lines
4.2 KiB
Python

from __future__ import annotations
import json
import re
from collections.abc import Callable
from http import HTTPStatus
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from urllib.parse import parse_qs, urlsplit
from . import NAME
from .errors import Conflict, EngineError, Held, Missing, ToolError, Unavailable
from .hub import Hub
GUARD = "X-Kvb-Orchestrator"
PLAIN_CSP = "default-src 'none'; frame-ancestors 'none'"
LENGTH = re.compile(r"[0-9]{1,9}")
QUERY_FIELDS = 32
class HubServer(ThreadingHTTPServer):
daemon_threads = True
hub: Hub
class Exchange(BaseHTTPRequestHandler):
server: HubServer
server_version = NAME
sys_version = ""
timeout = 60
def send(self, status: HTTPStatus, content_type: str, body: bytes, headers: dict[str, str]) -> None:
self.send_response(status)
common = {
"Content-Type": content_type,
"Content-Length": str(len(body)),
"Cache-Control": "no-store",
"X-Content-Type-Options": "nosniff",
"Referrer-Policy": "no-referrer",
}
for name, value in {**common, **headers}.items():
self.send_header(name, value)
self.end_headers()
self.wfile.write(body)
def send_text(self, status: HTTPStatus, message: str) -> None:
self.send(status, "text/plain; charset=utf-8", f"{message}\n".encode(), {"Content-Security-Policy": PLAIN_CSP})
def send_json(self, status: HTTPStatus, payload: dict) -> None:
self.send(status, "application/json", json.dumps(payload).encode(), {"Content-Security-Policy": PLAIN_CSP})
def not_allowed(self) -> None:
self.send_response(HTTPStatus.METHOD_NOT_ALLOWED)
self.send_header("Allow", "POST")
self.send_header("Content-Length", "0")
self.end_headers()
def answer(self, produce: Callable[[], dict], status: HTTPStatus) -> None:
self.attempt(produce, lambda payload: self.send_json(status, payload))
def attempt(self, produce: Callable[[], object], deliver: Callable[[object], None]) -> None:
try:
result = produce()
except ToolError as error:
self.send_text(HTTPStatus.BAD_REQUEST, str(error))
except Missing:
self.send_text(HTTPStatus.NOT_FOUND, "not found")
except Conflict as error:
self.send_json(HTTPStatus.CONFLICT, error.payload)
except Unavailable as error:
self.send_text(HTTPStatus.SERVICE_UNAVAILABLE, str(error))
except Held as error:
self.send_json(HTTPStatus.SERVICE_UNAVAILABLE, {"reason": error.reason})
except EngineError as error:
self.send_text(HTTPStatus.BAD_GATEWAY, str(error))
except OSError as error:
self.send_text(HTTPStatus.INTERNAL_SERVER_ERROR, f"storage failed: {error.strerror}")
else:
deliver(result)
def query(self) -> dict[str, list[str]]:
try:
return parse_qs(urlsplit(self.path).query, keep_blank_values=True, max_num_fields=QUERY_FIELDS)
except ValueError as error:
raise ToolError(str(error)) from error
def host(self) -> str | None:
hosts = self.headers.get_all("Host")
if hosts is None or len(hosts) != 1 or hosts[0] not in self.server.hub.hosts():
return None
return hosts[0]
def guarded(self, host: str) -> bool:
return self.headers.get_all(GUARD) == ["1"] and self.headers.get_all("Origin") == [f"http://{host}"]
def local(self, host: str) -> bool:
origins = self.headers.get_all("Origin")
return self.headers.get_all(GUARD) == ["1"] and (origins is None or origins == [f"http://{host}"])
def client(self) -> bool:
return self.headers.get_all(GUARD) == ["1"] and self.headers.get_all("Origin") is None
def body_length(self, limit: int) -> int | None:
length = self.headers.get("Content-Length")
if length is None or not LENGTH.fullmatch(length):
self.send_text(HTTPStatus.LENGTH_REQUIRED, "Content-Length required")
return None
if int(length) > limit:
self.send_text(HTTPStatus.REQUEST_ENTITY_TOO_LARGE, "body too large")
return None
return int(length)