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>
111 lines
4.2 KiB
Python
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)
|